@f1studio/form-spec 5.0.0-alpha.149 → 5.0.0-alpha.152

package/FormSpec.TS/fable_modules/Fable.Promise.3.2.0/Promise.fs.ts.map

@@ -1 +0,0 @@
-{"version":3,"sources":["./Promise.fs"],"names":["a","fn","x","result","e","pr","p","enumerator","seq","body","guard","While","this","compensation","er","generator","onSuccess","onError","TryFinally","binder","resource","copyOfStruct"],"mappings":";;;;;;;;;;;;;;;;;;;;;WA4LS,AAALA;AAAmB,AAAAC,WAAGC;eAAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6YzB,AAAgBF;;;;;;;;;;;;;;;;;;;WAwBX,AAALA,iFAAU,sBAAAC,IAAAE;;;;;;;;;;;;;;;;;;;;;;;;WA8BL,AAALH;AACU,YAAA,AAAAA;AAGEI,yBACJ,AAAAJ;AAAA,mBAAA,4CAAYI;;;AAFJC,oCAAR,AAAAJ,GAAA,AAAAD;AAAQ,mBAAA,AAAAK;;;;;;;;;;;;;;;;;;;;;WA0BX,AAALL,iFAAU,2BAAAC,IAAAE;;;;;;;;;;;;;;;;;QA4BQE;AAFFC,2BAAI,gBAAK;AACZC,uCAAA,cAAAC;AAAT;AAAA,eAAS,AAAAD;AAALP,yBAAK,AAAAO;AACL,AAAAD,kBAAUD,KAALC,GAAK,AAAAD,6BAAgB,AAAAI,KAAKT;;;;AADnC,oBAASO;;WAETD;;;;AAMA,QAAG,AAAAI;AACE,eAAA,AAAsCJ,4BAAtB,AAAAK,8BAAAC,OAAWF,OAAOJ;;;AAClC,eAAA,gBAAI;;;;;WAYT,AAA\u002BEA;AAAxD,AAAAO;eAAgBX;;AAAc,AAAAW;AAAgB,cAAMC;;;;;;;AAUnE;AAAI,uBAAA,AAAAC,sBAAqBC,WAAWC;;;AAEhC,oBAAG,AAAWA;AAAc,2BAAA,eAAOH;;;AAE/B;AAAkBd,uCAAd,AAAAiB,QAAQH;AAAM,\u002BBAAA,gBAAAd;;;AACP,\u002BBAAA,eAAOc;;;;;;AAE1B;AAAI,uBAAA,AAAAC,kBAAkBE;;;AAElB;AAAkBjB,mCAAd,AAAAiB,UAAQH;AAAM,2BAAA,gBAAAd;;;AACP,2BAAA,eAAOc;;;;;;;;WAIe,AAAAR,uBAAWJ;;;;WAGxD,AAAAgB,wCAAAN,OAAgB,AAAAO,OAAOC;AAAqBC,\u002BBAAAD;AAAA,oBAAAC","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs

@@ -1,31 +0,0 @@
-[<AutoOpen>]
-module PromiseImpl
-
-let promise = Promise.PromiseBuilder()
-
-[<RequireQualifiedAccess>]
-module SettledValue =
-
-    /// <summary>
-    /// Helper functionm to convert a settled result into an F# result
-    /// </summary>
-    /// <param name="p">The settled result</param>
-    /// <typeparam name="'T"></typeparam>
-    /// <returns>The F# result</returns>
-    /// <example>
-    /// <code lang="fsharp">
-    /// Promise.allSettled [success; rejection]
-    /// |> Promise.iter (fun results ->
-    ///     for result in results do 
-    ///       match SettledValue.toResult result  with 
-    ///       | Ok value ->
-    ///         printfn "Success: %A" value
-    ///       | Error err -> 
-    ///         eprintfn "Error: %O" err
-    /// )
-    /// </code>
-    /// </example>
-    let toResult (p: Promise.SettledValue<'T>) =
-        match p.status with 
-        | Promise.Fulfilled -> Ok p.value.Value
-        | Promise.Rejected -> Error p.reason.Value

package/FormSpec.TS/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.ts.map

@@ -1 +0,0 @@
-{"version":3,"sources":["./PromiseImpl.fs"],"names":["matchValue","p"],"mappings":";;;;uCAGc;;;;;;AAyBAA,sCAAA,AAAAC;AAAA,QAAA,AAAAD;8CAEsB,MAAA,AAAAC;;;2CADF,MAAA,AAAAA","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Extensions.fs

@@ -1,17 +0,0 @@
-[<AutoOpen>]
-module Fable.React.Extensions
-
-open Fable.Core
-
-type Browser.Types.Event with
-    /// Access the value from target
-    /// Equivalent to `(this.target :?> HTMLInputElement).value`
-    [<Emit("$0.target.value")>]
-    member this.Value: string =
-        (this.target :?> Browser.Types.HTMLInputElement).value
-
-    /// Access the checked property from target
-    /// Equivalent to `(this.target :?> HTMLInputElement).checked`
-    [<Emit("$0.target.checked")>]
-    member this.Checked: bool =
-        (this.target :?> Browser.Types.HTMLInputElement).``checked``

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs

@@ -1,152 +0,0 @@
-namespace Fable.React
-
-open Fable.Core
-
-type IStateHook<'T> =
-    [<Emit("$0[0]")>]
-    abstract current: 'T
-    [<Emit("$0[1]($1)")>]
-    abstract update: 'T -> unit
-    [<Emit("$0[1]($1)")>]
-    abstract update: ('T -> 'T) -> unit
-
-// Alias kept for backwards compatibility
-type IRefHook<'T> = IRefValue<'T>
-
-type IReducerHook<'State,'Msg> =
-    [<Emit("$0[0]")>]
-    abstract current: 'State
-    [<Emit("$0[1]($1)")>]
-    abstract update: 'Msg -> unit
-
-type ITransitionHook =
-    [<Emit("$0[0]")>]
-    abstract isPending: bool
-    [<Emit("$0[1]($1)")>]
-    abstract startTransition: callback: (unit -> unit) -> unit
-
-type IHooks =
-    /// Returns the current state with a function to update it.
-    /// More info at  https://reactjs.org/docs/hooks-reference.html#usestate
-    abstract useState: initialState: 'T -> IStateHook<'T>
-
-    /// Returns the current state with a function to update it.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usestate
-    [<Emit("$0.useState($1)")>]
-    abstract useStateLazy: initialState: (unit->'T) -> IStateHook<'T>
-
-    /// Accepts a function that contains imperative, possibly effectful code.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#useeffect
-    abstract useEffect: effect: (unit->unit) * ?dependencies: obj[] -> unit
-
-    /// Accepts a function that contains imperative, possibly effectful code.
-    /// The signature is identical to useEffect, but it fires synchronously after 
-    /// all DOM mutations. Use this to read layout from the DOM and synchronously 
-    /// re-render. Updates scheduled inside useLayoutEffect will be flushed 
-    /// synchronously, before the browser has a chance to paint.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#uselayouteffect
-    abstract useLayoutEffect: effect: (unit->unit) * ?dependencies: obj[] -> unit
-
-    /// Accepts a function that contains effectful code and returns a disposable for clean-up
-    /// More info at https://reactjs.org/docs/hooks-reference.html#useeffect
-    [<Emit("""$0.useEffect(() => {
-        const disp = $1();
-        return () => disp.Dispose();
-    }{{, $2}})""")>]
-    abstract useEffectDisposable: effect: (unit->System.IDisposable) * ?dependencies: obj[] -> unit
-
-    // abstract useCallback (callback: unit -> unit, dependencies: obj[]): unit -> unit
-
-    /// Accepts a "create" function and an array of dependencies and returns a memoized value
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usememo
-    abstract useMemo: callback: (unit->'T) * dependencies: obj[] -> 'T
-
-    /// The returned object will persist for the full lifetime of the component.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#useref
-    abstract useRef: initialValue: 'T -> IRefValue<'T>
-
-    /// Accepts a context object (the value returned from createContext) and
-    /// returns the current context value for that context. The current context
-    /// value is determined by the value prop of the nearest <MyContext.Provider>
-    /// above the calling component in the tree.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usecontext
-    abstract useContext: ctx: IContext<'T> -> 'T
-
-    /// Display a label for custom hooks in React DevTools.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usedebugvalue
-    abstract useDebugValue: label: string -> unit
-
-    /// Defers formatting of debug value until the Hook is actually inspected
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usedebugvalue
-    abstract useDebugValue: value: 'T * format: ('T->string) -> unit
-
-    /// An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usereducer
-    abstract useReducer: reducer: ('State -> 'Msg -> 'State) * initialState: 'State -> IReducerHook<'State, 'Msg>
-
-    /// An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usereducer
-    abstract useReducer: reducer: ('State -> 'Msg -> 'State) * initialArg: 'I * init: ('I -> 'State) -> IReducerHook<'State, 'Msg>
-
-    /// Returns a stateful value for the pending state of the transition, and a function to start it.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usetransition
-    /// Requires React 18.
-    abstract useTransition: unit -> ITransitionHook
-
-    /// useId is a hook for generating unique IDs that are stable across the server and client, while avoiding hydration mismatches.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#useid
-    /// Requires React 18.
-    abstract useId: unit -> string
-
-    /// useDeferredValue accepts a value and returns a new copy of the value that will defer to more urgent updates. If the current render is the result of an urgent update, like user input, React will return the previous value and then render the new value after the urgent render has completed.
-    /// More info at https://reactjs.org/docs/hooks-reference.html#usedeferredvalue
-    /// Requires React 18.
-    abstract useDeferredValue: 'T -> 'T
-
-[<AutoOpen>]
-module HookBindings =
-    let private makeDummyStateHook value =
-        { new IStateHook<'T> with
-            member __.current = value
-            member __.update(x: 'T) = ()
-            member __.update(f: 'T->'T) = () }
-
-    let private makeDummyReducerHook state =
-        { new IReducerHook<'State,'Msg> with
-            member __.current = state
-            member __.update(msg: 'Msg) = () }
-
-    let private makeDummyTransitionHook () =
-        { new ITransitionHook with
-            member __.isPending = false
-            member __.startTransition callback = () }
-
-    #if FABLE_REPL_LIB
-    [<Global("React")>]
-    #else
-    [<Import("*", "react")>]
-    #endif
-    let Hooks: IHooks =
-        // Placeholder for SSR
-        { new IHooks with
-            member __.useState(initialState: 'T) =
-                makeDummyStateHook initialState
-            member __.useStateLazy(initialState) =
-                makeDummyStateHook (initialState())
-            member __.useEffect(effect, dependencies) = ()
-            member __.useEffectDisposable(effect, dependencies) = ()
-            member __.useMemo(callback, dependencies) = callback()
-            member __.useRef(initialValue) =
-                { new IRefValue<_> with
-                    member __.current with get() = initialValue and set _ = () }
-            member __.useContext ctx =
-                (ctx :?> ISSRContext<_>).DefaultValue
-            member __.useDebugValue(label): unit = ()
-            member __.useDebugValue(value, format): unit = ()
-            member __.useReducer(reducer,initialState) = makeDummyReducerHook initialState
-            member __.useReducer(reducer, initialArgument, init) = makeDummyReducerHook (init initialArgument)
-            member __.useTransition() = makeDummyTransitionHook()
-            member __.useDeferredValue value = value
-            member __.useId() = ""
-            member __.useLayoutEffect(effect, dependencies) = ()
-        }

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs.ts.map

@@ -1 +0,0 @@
-{"version":3,"sources":["./Fable.React.Hooks.fs"],"names":["value","state"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6GgCA;;;;;;;;;;iBAMAC;;;;;;;;mBAKE","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Types.fableproj

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <Version>18.3.0</Version>
-    <PackageVersion>18.3.0</PackageVersion>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <!-- <DefineConstants>$(DefineConstants);FABLE_COMPILER</DefineConstants> -->
-    <PackageTags>fsharp;fable;javascript;f#;js;react;fable-binding;fable-javascript</PackageTags>
-  </PropertyGroup>
-  <PropertyGroup>
-    <NpmDependencies>
-      <NpmPackage Name="react" Version="gte 18.0.0 lt 19.0.0" ResolutionStrategy="Max" />
-    </NpmDependencies>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="Fable.React.fs" />
-    <Compile Include="Fable.React.Hooks.fs" />
-    <Compile Include="Fable.React.Extensions.fs" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Fable.Core" Version="3.2.7" />
-    <PackageReference Include="Fable.Browser.Dom" Version="2.4.4" />
-    <PackageReference Update="FSharp.Core" Version="4.7.2" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="*.fsproj; *.fs" PackagePath="fable\" />
-  </ItemGroup>
-</Project>

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.fs

@@ -1,218 +0,0 @@
-namespace Fable.React
-
-open System
-open Fable.Core
-
-type [<AllowNullLiteral>] ReactElement =
-    interface end
-
-type ReactElementType =
-    interface end
-
-type ReactElementType<'props> =
-    inherit ReactElementType
-
-type IRefValue<'T> =
-    abstract current: 'T with get, set
-
-type IContext<'T> =
-    interface end
-
-type ISSRContext<'T> =
-    inherit IContext<'T>
-    abstract DefaultValue: 'T
-
-type IReactExports =
-    /// Create and return a new React element of the given type. The type argument can be either a tag name string (such as 'div' or 'span'), a React component type (a class or a function), or a React fragment type.
-    abstract createElement: comp: obj * props: obj * [<ParamList>] children: ReactElement seq -> ReactElement
-
-    /// Creates a Context object. When React renders a component that subscribes to this Context object it will read the current context value from the closest matching Provider above it in the tree.
-    abstract createContext: defaultValue: 'T -> IContext<'T>
-
-    /// React.createRef creates a ref that can be attached to React elements via the ref attribute.
-    abstract createRef: initialValue: 'T -> IRefValue<'T>
-
-    /// React.forwardRef creates a React component that forwards the ref attribute it receives to another component below in the tree.
-    abstract forwardRef: fn: ('props -> IRefValue<'T> option -> ReactElement) -> ReactElementType<'props>
-
-    /// If your component renders the same result given the same props, you can wrap it in a call to React.memo for a performance boost in some cases by memoizing the result. This means that React will skip rendering the component, and reuse the last rendered result.
-    abstract memo: render: ('props -> ReactElement) * areEqual: ('props -> 'props -> bool) -> ReactElementType<'props>
-
-    /// The React.Fragment component lets you return multiple elements in a render() method without creating an additional DOM element.
-    abstract Fragment: ReactElementType<obj>
-
-    /// React.Suspense lets you specify the loading indicator in case some components in the tree below it are not yet ready to render. In the future we plan to let Suspense handle more scenarios such as data fetching.
-    abstract Suspense: ReactElementType<obj>
-    
-    /// React.lazy() lets you define a component that is loaded dynamically. This helps reduce the bundle size to delay loading components that aren’t used during the initial render.
-    abstract ``lazy``: f: (unit -> JS.Promise<'TIn>) -> 'TOut
-
-    /// React.startTransition lets you mark updates inside the provided callback as transitions. This method is designed to be used when React.useTransition is not available.
-    /// Requires React 18.
-    abstract startTransition: callback: (unit -> unit) -> unit
-
-    /// The React version.
-    abstract version: string
-
-module ReactBindings =
-    /// Mainly intended for internal use
-    #if FABLE_REPL_LIB
-    [<Global("React")>]
-    #else
-    [<Import("*", "react")>]
-    #endif
-    let React: IReactExports = jsNative
-
-/// Create a React component by inheriting this class as follows
-///
-/// ```
-/// type MyComponent(initialProps) =
-///     inherit React.Component<MyProps, MyState>(initialProps)
-///     base.setInitState({ value = 5 })
-///
-///     override this.render() =
-///         // Don't use captured `initialProps` from constructor,
-///         // use `this.props` instead (updated version)
-///         let msg = sprintf "Hello %s, you have %i €"
-///                     this.props.name this.state.value
-///         div [] [ofString msg]
-/// ```
-type [<AbstractClass; Import("Component", "react")>] Component<'P,'S>(initProps: 'P) =
-    [<Emit("$0.props")>]
-    member __.props: 'P = initProps
-
-    [<Emit("Array.prototype.concat($0.props.children || [])")>]
-    member val children: ReactElement array = [| |] with get, set
-
-    [<Emit("$0.state")>]
-    member val state: 'S = Unchecked.defaultof<'S> with get, set
-
-    /// ATTENTION: Within the constructor, use `setInitState`
-    /// Enqueues changes to the component state and tells React that this component and its children need to be re-rendered with the updated state. This is the primary method you use to update the user interface in response to event handlers and server responses.
-    /// Think of setState() as a request rather than an immediate command to update the component. For better perceived performance, React may delay it, and then update several components in a single pass. React does not guarantee that the state changes are applied immediately.
-    /// setState() does not always immediately update the component. It may batch or defer the update until later. This makes reading this.state right after calling setState() a potential pitfall. Instead, use componentDidUpdate or a setState callback (setState(updater, callback)), either of which are guaranteed to fire after the update has been applied. If you need to set the state based on the previous state, read about the updater argument below.
-    /// setState() will always lead to a re-render unless shouldComponentUpdate() returns false. If mutable objects are being used and conditional rendering logic cannot be implemented in shouldComponentUpdate(), calling setState() only when the new state differs from the previous state will avoid unnecessary re-renders.
-    [<Obsolete("This overload is unsafe because it forces use of this.state. Use this.setState(updater: 'S->'P->'S) instead.")>]
-    [<Emit("$0.setState($1)")>]
-    member x.setState(value: 'S): unit = x.state <- value
-
-    /// Overload of `setState` accepting updater function with the signature: `(prevState, props) => stateChange`
-    /// prevState is a reference to the previous state. It should not be directly mutated. Instead, changes should be represented by building a new object based on the input from prevState and props.
-    /// Both prevState and props received by the updater function are guaranteed to be up-to-date. The output of the updater is shallowly merged with prevState.
-    [<Emit("$0.setState($1)")>]
-    member x.setState(updater: 'S->'P->'S): unit = x.state <- updater x.state x.props
-
-    /// This method can only be called in the constructor
-    [<Emit("this.state = $1")>]
-    member x.setInitState(value: 'S): unit = x.state <- value
-
-    /// By default, when your component’s state or props change, your component will re-render. If your render() method depends on some other data, you can tell React that the component needs re-rendering by calling forceUpdate().
-    /// Calling forceUpdate() will cause render() to be called on the component, skipping shouldComponentUpdate(). This will trigger the normal lifecycle methods for child components, including the shouldComponentUpdate() method of each child. React will still only update the DOM if the markup changes.
-    /// Normally you should try to avoid all uses of forceUpdate() and only read from this.props and this.state in render().
-    [<Emit("$0.forceUpdate($1)")>]
-    member __.forceUpdate(?callBack: unit->unit): unit = ()
-
-    [<Emit("$0.isMounted()")>]
-    member __.isMounted(): bool = false
-
-    /// Invoked immediately before mounting occurs. It is called before render(), therefore calling setState() synchronously in this method will not trigger an extra rendering. Generally, we recommend using the constructor() instead.
-    /// Avoid introducing any side-effects or subscriptions in this method. For those use cases, use componentDidMount() instead.
-    /// This is the only lifecycle hook called on server rendering.
-    abstract componentWillMount: unit -> unit
-    default __.componentWillMount () = ()
-
-    /// Invoked immediately after a component is mounted. Initialization that requires DOM nodes should go here. If you need to load data from a remote endpoint, this is a good place to instantiate the network request.
-    /// This method is a good place to set up any subscriptions. If you do that, don’t forget to unsubscribe in componentWillUnmount().
-    /// Calling setState() in this method will trigger an extra rendering, but it is guaranteed to flush during the same tick. This guarantees that even though the render() will be called twice in this case, the user won’t see the intermediate state. Use this pattern with caution because it often causes performance issues. It can, however, be necessary for cases like modals and tooltips when you need to measure a DOM node before rendering something that depends on its size or position.
-    abstract componentDidMount: unit -> unit
-    default __.componentDidMount () = ()
-
-    /// Invoked before a mounted component receives new props. If you need to update the state in response to prop changes (for example, to reset it), you may compare this.props and nextProps and perform state transitions using this.setState() in this method.
-    /// Note that React may call this method even if the props have not changed, so make sure to compare the current and next values if you only want to handle changes. This may occur when the parent component causes your component to re-render.
-    /// React doesn’t call componentWillReceiveProps() with initial props during mounting. It only calls this method if some of component’s props may update. Calling this.setState() generally doesn’t trigger componentWillReceiveProps().
-    abstract componentWillReceiveProps: nextProps: 'P -> unit
-    default __.componentWillReceiveProps (_) = ()
-
-    /// Use shouldComponentUpdate() to let React know if a component’s output is not affected by the current change in state or props. The default behavior is to re-render on every state change, and in the vast majority of cases you should rely on the default behavior.
-    /// shouldComponentUpdate() is invoked before rendering when new props or state are being received. Defaults to true. This method is not called for the initial render or when forceUpdate() is used.
-    /// Returning false does not prevent child components from re-rendering when their state changes.
-    /// Currently, if shouldComponentUpdate() returns false, then componentWillUpdate(), render(), and componentDidUpdate() will not be invoked. Note that in the future React may treat shouldComponentUpdate() as a hint rather than a strict directive, and returning false may still result in a re-rendering of the component.
-    /// If you determine a specific component is slow after profiling, you may change it to inherit from React.PureComponent which implements shouldComponentUpdate() with a shallow prop and state comparison. If you are confident you want to write it by hand, you may compare this.props with nextProps and this.state with nextState and return false to tell React the update can be skipped.
-    /// We do not recommend doing deep equality checks or using JSON.stringify() in shouldComponentUpdate(). It is very inefficient and will harm performance.
-    abstract shouldComponentUpdate: nextProps: 'P * nextState: 'S -> bool
-    default __.shouldComponentUpdate (_, _) = true
-
-    /// Invoked immediately before rendering when new props or state are being received. Use this as an opportunity to perform preparation before an update occurs. This method is not called for the initial render.
-    /// Note that you cannot call this.setState() here; nor should you do anything else (e.g. dispatch a Redux action) that would trigger an update to a React component before componentWillUpdate() returns.
-    /// If you need to update state in response to props changes, use componentWillReceiveProps() instead.
-    /// > componentWillUpdate() will not be invoked if shouldComponentUpdate() returns false.
-    abstract componentWillUpdate: nextProps: 'P * nextState: 'S -> unit
-    default __.componentWillUpdate (_, _) = ()
-
-    /// Invoked immediately after updating occurs. This method is not called for the initial render.
-    /// Use this as an opportunity to operate on the DOM when the component has been updated. This is also a good place to do network requests as long as you compare the current props to previous props (e.g. a network request may not be necessary if the props have not changed).
-    /// > componentDidUpdate() will not be invoked if shouldComponentUpdate() returns false.
-    abstract componentDidUpdate: prevProps: 'P * prevState: 'S -> unit
-    default __.componentDidUpdate (_, _) = ()
-
-    /// Invoked immediately before a component is unmounted and destroyed. Perform any necessary cleanup in this method, such as invalidating timers, canceling network requests, or cleaning up any subscriptions that were created in componentDidMount().
-    abstract componentWillUnmount: unit -> unit
-    default __.componentWillUnmount () = ()
-
-    /// Error boundaries are React components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of the component tree that crashed. Error boundaries catch errors during rendering, in lifecycle methods, and in constructors of the whole tree below them.
-    /// A class component becomes an error boundary if it defines this lifecycle method. Calling setState() in it lets you capture an unhandled JavaScript error in the below tree and display a fallback UI. Only use error boundaries for recovering from unexpected exceptions; don’t try to use them for control flow.
-    /// For more details, see [Error Handling in React 16](https://reactjs.org/blog/2017/07/26/error-handling-in-react-16.html).
-    /// > Error boundaries only catch errors in the components below them in the tree. An error boundary can’t catch an error within itself.
-    abstract componentDidCatch: error: Exception * info: obj -> unit
-    default __.componentDidCatch (_, _) = ()
-
-    /// This function should be pure, meaning that it does not modify component state, it returns the same result each time it’s invoked, and it does not directly interact with the browser. If you need to interact with the browser, perform your work in componentDidMount() or the other lifecycle methods instead. Keeping render() pure makes components easier to think about.
-    /// > render() will not be invoked if shouldComponentUpdate() returns false.
-    abstract render: unit -> ReactElement
-
-    interface ReactElement
-
-/// A react component that implements `shouldComponentUpdate()` with a shallow prop and state comparison.
-///
-/// Usage:
-/// ```
-/// type MyComponent(initialProps) =
-///     inherit React.PureComponent<MyProps, MyState>(initialProps)
-///     base.setInitState({ value = 5 })
-///     override this.render() =
-///         let msg = sprintf "Hello %s, you have %i €"
-///                     this.props.name this.state.value
-///         div [] [ofString msg]
-/// ```
-type [<AbstractClass; Import("PureComponent", "react")>] PureComponent<'P, 'S>(props: 'P) =
-    inherit Component<'P, 'S>(props)
-
-/// A react component that implements `shouldComponentUpdate()` with a shallow prop comparison.
-///
-/// Usage:
-/// ```
-/// type MyComponent(initialProps) =
-///     inherit React.PureStatelessComponent<MyProps>(initialProps)
-///     override this.render() =
-///         let msg = sprintf "Hello %s, you have %i €"
-///                     this.props.name this.props.value
-///         div [] [ofString msg]
-/// ```
-type [<AbstractClass; Import("PureComponent", "react")>] PureStatelessComponent<'P>(props: 'P) =
-    inherit Component<'P, obj>(props)
-
-type FragmentProps = { key: string }
-
-type [<Import("Fragment", "react")>] Fragment(props: FragmentProps) =
-    interface ReactElement
-
-// These are not React interfaces but we add them here in case other Fable libraries need them
-
-type IProp =
-    interface end
-
-type IHTMLProp =
-    inherit IProp
-
-type IFragmentProp =
-    inherit IProp

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.fs.ts.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.ReactDom.Types.18.2.0/Fable.ReactDom.Types.fableproj

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <Version>18.2.0</Version>
-    <PackageVersion>18.2.0</PackageVersion>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <!-- <DefineConstants>$(DefineConstants);FABLE_COMPILER</DefineConstants> -->
-    <PackageTags>fsharp;fable;javascript;f#;js;react;fable-binding;fable-javascript</PackageTags>
-  </PropertyGroup>
-  <PropertyGroup>
-    <NpmDependencies>
-      <NpmPackage Name="react-dom" Version="gte 18.0.0 lt 19.0.0" ResolutionStrategy="Max" />
-    </NpmDependencies>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="Fable.ReactDom.fs" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Update="FSharp.Core" Version="4.7.2" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Fable.React.Types\Fable.React.Types.fsproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="*.fsproj; *.fs" PackagePath="fable\" />
-  </ItemGroup>
-</Project>

package/FormSpec.TS/fable_modules/Fable.ReactDom.Types.18.2.0/Fable.ReactDom.fs

@@ -1,82 +0,0 @@
-namespace Fable.React
-
-open Fable.Core
-open Fable.React
-open Browser.Types
-
-type IReactRoot =
-    /// Render a React element into the root.
-    abstract render: element: ReactElement -> unit
-
-    /// Remove the root from the DOM.
-    abstract unmount: unit -> unit
-
-type IRootOptions =
-    /// Optional callback called when React automatically recovers from errors.
-    abstract onRecoverableError: (obj -> unit) with get, set
-
-    /// Optional prefix React uses for ids generated by React.useId. Useful to avoid conflicts when using multiple roots on the same page. Must be the same prefix used on the server.
-    abstract identifierPrefix: string with get, set
-
-type ICreateRootOptions =
-    inherit IRootOptions
-
-type IHydrateRootOptions =
-    inherit IRootOptions
-
-type IReactDom =
-    /// Render a React element into the DOM in the supplied container.
-    /// If the React element was previously rendered into container, this will perform an update on it and only mutate the DOM as necessary to reflect the latest React element.
-    /// If the optional callback is provided, it will be executed after the component is rendered or updated.
-    abstract render: element: ReactElement * container: Element * ?callback: (unit->unit) -> unit
-
-    /// Same as render(), but is used to hydrate a container whose HTML contents were rendered by ReactDOMServer. React will attempt to attach event listeners to the existing markup.
-    abstract hydrate: element: ReactElement * container: Element * ?callback: (unit->unit) -> unit
-
-    /// Remove a mounted React component from the DOM and clean up its event handlers and state. If no component was mounted in the container, calling this function does nothing. Returns true if a component was unmounted and false if there was no component to unmount.
-    abstract unmountComponentAtNode: container: Element -> bool
-
-    /// Creates a portal. Portals provide a way to render children into a DOM node that exists outside the hierarchy of the DOM component.
-    abstract createPortal: child: ReactElement * container: Element -> ReactElement
-    
-    /// Force React to flush any updates inside the provided callback synchronously. This ensures that the DOM is updated immediately.
-    abstract flushSync: callback: (unit -> unit) -> unit
-
-type IReactDomClient =
-    /// Create a React root for the supplied container and return the root. The root can be used to render a React element into the DOM with render.
-    /// Requires React 18.
-    abstract createRoot: container: Element * ?options: ICreateRootOptions -> IReactRoot
-
-    /// Same as createRoot(), but is used to hydrate a container whose HTML contents were rendered by ReactDOMServer. React will attempt to attach event listeners to the existing markup.
-    /// Requires React 18.
-    abstract hydrateRoot: container: Element * element: ReactElement * ?options: IHydrateRootOptions -> IReactRoot
-
-type IReactDomServer =
-    /// Render a React element to its initial HTML. This should only be used on the server. React will return an HTML string. You can use this method to generate HTML on the server and send the markup down on the initial request for faster page loads and to allow search engines to crawl your pages for SEO purposes.
-    /// If you call ReactDOM.render() on a node that already has this server-rendered markup, React will preserve it and only attach event handlers, allowing you to have a very performant first-load experience.
-    abstract renderToString: element: ReactElement -> string
-
-    /// Similar to renderToString, except this doesn't create extra DOM attributes such as data-reactid, that React uses internally. This is useful if you want to use React as a simple static page generator, as stripping away the extra attributes can save lots of bytes.
-    abstract renderToStaticMarkup: element: ReactElement -> string
-
-[<AutoOpen>]
-module ReactDomBindings =
-    #if FABLE_REPL_LIB
-    [<Global("ReactDOM")>]
-    #else
-    [<Import("*", "react-dom")>]
-    #endif
-    let ReactDom: IReactDom = jsNative
-
-    /// Requires React 18.
-    #if FABLE_REPL_LIB
-    [<Global("ReactDOM")>]
-    #else
-    [<Import("*", "react-dom/client")>]
-    #endif
-    let ReactDomClient: IReactDomClient = jsNative
-
-    #if !FABLE_REPL_LIB
-    [<Import("default", "react-dom/server")>]
-    let ReactDomServer: IReactDomServer = jsNative
-    #endif

package/FormSpec.TS/fable_modules/Fable.ReactDom.Types.18.2.0/Fable.ReactDom.fs.ts.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Feliz.2.8.0/BorderStyle.fs

@@ -1,59 +0,0 @@
-namespace Feliz
-
-open Fable.Core
-open Feliz.Styles
-
-[<Erase>]
-type borderStyle =
-    /// Specifies a dashed border.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=dashed
-    static member inline dashed : IBorderStyle = unbox "dashed"
-    /// Specifies a dotted border.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=dotted
-    static member inline dotted : IBorderStyle = unbox "dotted"
-    /// Specifies a double border.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=double
-    static member inline double : IBorderStyle = unbox "double"
-    /// Specifies a 3D grooved border. The effect depends on the border-color value.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=groove
-    static member inline groove : IBorderStyle = unbox "groove"
-    /// The same as "none", except in border conflict resolution for table elements.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=hidden
-    static member inline hidden : IBorderStyle = unbox "hidden"
-    /// Inherits this property from its parent element.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=inherit
-    ///
-    /// Read about inherit https://www.w3schools.com/cssref/css_inherit.asp
-    static member inline inheritFromParent : IBorderStyle = unbox "inherit"
-    /// Sets this property to its default value.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=initial
-    ///
-    /// Read about initial value https://www.w3schools.com/cssref/css_initial.asp
-    static member inline initial : IBorderStyle = unbox "initial"
-    /// Specifies a 3D inset border. The effect depends on the border-color value.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=inset
-    static member inline inset : IBorderStyle = unbox "inset"
-    /// Default value. Specifies no border.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=none
-    static member inline none : IBorderStyle = unbox "none"
-    /// Specifies a 3D outset border. The effect depends on the border-color value.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=outset
-    static member inline outset : IBorderStyle = unbox "outset"
-    /// Specifies a 3D ridged border. The effect depends on the border-color value.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=ridge
-    static member inline ridge : IBorderStyle = unbox "ridge"
-    /// Specifies a solid border.
-    ///
-    /// See example https://www.w3schools.com/cssref/playit.asp?filename=playcss_border-style&preval=solid
-    static member inline solid : IBorderStyle = unbox "solid"