sveast 0.9.2 → 0.9.4

package/README.md

@@ -31,9 +31,11 @@ ast.fragment.nodes; // [Text, RegularElement]
 | [`createParser`, `createModuleParser`](#smaller-bundles-sveastcore-and-sveastmodule) | The parsers without TypeScript, named HTML entities or the template parser, for a smaller bundle | `sveast/core`, `sveast/module` |
 | [`isValidType`](#isvalidtypetext-options--boolean) | Whether a JSDoc type is safe to copy into a `.d.ts` | `sveast` |
 | [`isRunesMode`](#isrunesmodesource--boolean) | Whether svelte compiles a component in runes mode, mostly without parsing it | `sveast` |
-| [`walk`, `visitorKeys`, `markupVisitorKeys`](#walknode-visitor-keys--void) | Visit, skip, stop at or replace nodes, in the whole AST or only the markup | `sveast`, `sveast/walk` |
+| [`walk`, `visitorKeys`, `markupVisitorKeys`, `valueVisitorKeys`, `skipTypeWrappers`](#walknode-visitor-keys--void) | Visit, skip, stop at or replace nodes, in the whole AST, only the markup, or everything but TypeScript's types | `sveast`, `sveast/walk` |
+| [`children`, `forEachChild`](#childrennode-keys--node-and-foreachchildnode-callback-keys--void) | A node's children, cached or without allocating | `sveast`, `sveast/walk` |
 | [`isReference`](#isreferencenode-parent--boolean), [`extractIdentifiers`](#extractidentifierspattern--identifier) | Which identifiers are references, and which ones a pattern declares | `sveast`, `sveast/walk` |
-| [`createLocator`](#createlocatorsource--offset--position) | Lines and columns for the nodes you report, without parsing with `loc` | `sveast`, `sveast/walk` |
+| [`analyzeScopes`](#analyzescopesast--scopes) | Which declaration each name refers to, and every read and write of it | `sveast`, `sveast/scope` |
+| [`createLocator`, `locate`](#createlocatorsource--offset--position) | Lines and columns for the nodes you report, without parsing with `loc` | `sveast`, `sveast/walk` |
 
 ## Migrating from svelte/compiler
 
@@ -307,7 +309,24 @@ walk(
 );
 ```
 
-`sveast/walk` exports `walk`, `SKIP`, `STOP`, `visitorKeys`, `markupVisitorKeys`, `isReference`, `extractIdentifiers`, `createLocator` and the types without loading a parser, for code that walks ASTs from elsewhere, such as a cache.
+`valueVisitorKeys` leaves out TypeScript's types: no type annotation, type parameter or type argument, no `implements`, and no type in `as` or `satisfies`. It reaches every value and binding, so an `Identifier` it reaches is never a type's name, and a tool that rewrites values can't fold `size` in `type S = typeof size` or `let a: typeof size`. It still enters a declaration that holds only types, such as `type`, `interface` or an index signature, but not its children, and of `declare function f(): void` it visits only the name. The TypeScript nodes whose children it visits hold values: `as`, `satisfies`, `<T>a`, `a!` and `a<T>` their expression, an enum its members, a namespace its body, `import a = b` and `export =` their value, and a parameter property its parameter. Walking with it takes about as long as walking everything.
+
+`skipTypeWrappers(node)` gives the value inside those wrappers: `a` for `a as T`, `a satisfies T`, `<T>a`, `a!`, `a<T>` and any nesting of them, and `node` itself for anything else, for code that reads values, such as an evaluator deciding whether `size as Size` is a constant.
+
+`sveast/walk` exports `walk`, `SKIP`, `STOP`, `visitorKeys`, `markupVisitorKeys`, `valueVisitorKeys`, `skipTypeWrappers`, `children`, `forEachChild`, `isReference`, `extractIdentifiers`, `createLocator`, `locate` and the types without loading a parser, for code that walks ASTs from elsewhere, such as a cache.
+
+### `children(node, keys?) => Node[]` and `forEachChild(node, callback, keys?) => void`
+
+The child nodes `walk` would visit next, in source order, for a traversal of your own, such as one that evaluates expressions and decides per node what to visit. `forEachChild(node, (child, key, index) => ...)` calls back with each child, the field that holds it, and its index when the field is an array, and allocates nothing. `children(node)` returns an array that it makes on the first call for each node and returns again after, so a tool that walks the same tree many times lists each node's children once. ASTs don't change after `parse`, so the cache stays right unless you change one, for instance by replacing a node with `walk`; don't change the array. Both take `keys` as `walk` does and throw on a node type it has no entry for.
+
+```ts
+import { forEachChild, valueVisitorKeys } from "sveast/walk";
+
+function visit(node) {
+  if (node.type === "ConditionalExpression") return evaluateBranches(node);
+  forEachChild(node, visit, valueVisitorKeys);
+}
+```
 
 ### `isReference(node, parent) => boolean`
 
@@ -340,6 +359,52 @@ if (declaration.type === "VariableDeclaration") {
 }
 ```
 
+### `analyzeScopes(ast) => Scopes`
+
+Finds the scopes of a component, its scripts and markup together, or of a module: which declaration each name refers to, and where each binding is read, written or subscribed to. It resolves names as svelte's analyzer does, which `tests/scope.test.ts` checks on the corpus: on 12,548 components from the corpus, svelte's tests and the Svelte projects listed under parity, they agree on all 208,797 names they both resolve, but for a class expression's name inside its body, a snippet's own name and a `var` declared twice, where sveast follows JavaScript.
+
+```ts
+import { parse } from "sveast";
+import { analyzeScopes } from "sveast/scope";
+
+const ast = parse(`<script>
+  let { size = "md" } = $props();
+  function label(size) { return size; }
+</script>
+<Tooltip let:direction={actual}>{actual} {size}</Tooltip>`);
+const scopes = analyzeScopes(ast);
+
+const size = scopes.instance.get("size");
+size?.prop; // "size"
+size?.rune; // "$props"
+size?.initial; // the Literal "md"
+size?.references.length; // 1: the parameter in `label` is another binding
+size?.references.some((reference) => reference.writes || reference.mutates); // false
+```
+
+It returns:
+
+- **`module`** and **`instance`**, the scopes of `<script module>` and `<script>` (one scope, for a module). A `Scope` has the `node` that makes it, its `parent`, its `declarations` by name, and `get(name)`, the binding a name refers to there, or `null` for a global.
+- **`scopeOf(node)`**, the scope a node is in; `null` in a type, the `<style>` or another AST.
+- **`bindingOf(identifier)`**, the binding an `Identifier` declares or refers to; `null` for a global, a property key or a name in a type.
+- **`referenceOf(identifier)`**, the `Reference` an `Identifier` is, to tell a read from a write or a store subscription; `null` for one that declares a binding or isn't a reference.
+- **`declaredIn(node)`**, the bindings of the scope a node makes: a function's parameters (its body's declarations are its body's), a block's or an each block's declarations, a snippet's parameters, or an element's `let:` names.
+
+A `Binding` has its `name`, its `kind`, the `Identifier` that declares it as `node` (`null` for an each block's index and for `let:x` without a value), the `declaration` that holds it, its `scope` and its `references`. `initial` is what it starts as, as svelte's analyzer has it: an initializer, or for a prop destructured from `$props()`, its default without `$bindable`. `rune` is the rune its initializer calls, such as `"$state"`, `"$derived"` or `"$props"`, unless a binding or a store shadows it, and `prop` the name a parent passes a prop as: `"class"` for `klass` in `let { class: klass } = $props()` or `export { klass as class }`, `"size"` for `export let size`.
+
+A `Reference` has its `Identifier` as `node`, its `parent`, its `scope` and its `binding`, and says whether it `reads` the value (all but a plain `=`'s target), `writes` it (`=`, `+=`, `++`, `bind:`, `for (a of b)`), or `mutates` it (`a` in `a.b = c` and `bind:value={a.b}`), and whether it's a `store` subscription. Names the markup holds as strings, such as `Foo` in `<Foo.Bar>`, `a` in `use:a`, `transition:a` and `animate:a`, and `color` in `style:color`, get a new `Identifier` with the name's `start` and `end`.
+
+The markup's scopes are svelte's:
+
+- `{#each items as item, i (key)}` declares `item` and `i` for the key and the body, but not for `{:else}`.
+- A snippet's name is declared where the snippet is, and its parameters inside it. A top-level snippet is in the markup's scope, so a `<script>` that uses one refers to a global, as in svelte's analyzer.
+- `{@const}` declares a name for its whole block or element, `{:then value}` and `{:catch error}` for their branch.
+- `let:` declares a name for the element's attributes and children, or for a component's default slot; children with a `slot` attribute get their own scope. `let:a={b}` declares `b`, `let:a` declares `a`.
+- `$count`, without a declaration of `$count`, is a subscription to `count`, unless it's a rune: `$state` refers to a store `state` only if `state` isn't itself made by a rune.
+- `$: a = b` declares `a` if nothing else does, and writes it: the assignment is one of its references.
+
+Names in TypeScript's types aren't references, and `type` and `interface` declare nothing; it skips them with `valueVisitorKeys`. Enums, enum members and namespaces are declared. It doesn't change the AST, and takes less than half as long as parsing it.
+
 ### `createLocator(source) => (offset) => Position`
 
 A function from an offset to its `{ line, column }`, line from 1 and column from 0, as `loc: true` gives them: for a tool that parses without `loc`, which is faster, and needs lines only for what it reports. Lines are found on the first call, and each lookup starts its search at the line found last, so lookups in source order are fastest. Lines end at `\n`, as in the markup's `loc` and `ParseError`; acorn's `loc` in scripts and modules also ends them at a lone `\r`, U+2028 and U+2029. `parse` drops a leading byte order mark, so pass the source without one.
@@ -355,6 +420,14 @@ walk(parse(source), {
 });
 ```
 
+`locate(source, offset)` gives the same `{ line, column }` without keeping a locator: it keeps the lines of the last 64 sources it was called with, so a tool that reports nodes from many files, in any order, looks lines up once per file rather than scanning each from the start.
+
+```ts
+import { locate } from "sveast";
+
+`${file}:${locate(source, node.start).line}`;
+```
+
 ### Types
 
 `AST` is svelte's `AST` namespace (`AST.Root`, `AST.RegularElement`, `AST.CSS.Rule`, ...), corrected to match what the parser returns: `name_loc` and a comment's `loc` are optional, `Root.instance`/`module` are absent rather than `null` when there's no such `<script>`, `Root.js` is declared, and every directive has `modifiers`. Each function's options and results are exported too, e.g. `ParseOptions` and `LexedStatement`.

package/core.js

@@ -1 +1 @@
-import"./shared-40v3xx3k.js";import"./shared-5kdpxrm3.js";import"./shared-zd01zsyh.js";import{e}from"./shared-yxr92tk5.js";import{me}from"./shared-k5pfyxpa.js";import{D}from"./shared-x7fez4k2.js";import"./shared-4y1phpr0.js";import{g}from"./shared-t30czg6b.js";import{b}from"./shared-a454y0yc.js";import{U,ut}from"./shared-fcgh2ks8.js";function u(o={}){let p=U(o.typescript),s={typescript:p,entityNames:ut(o.entities)??me};return{parse:(t,r)=>D(t,r,s),parseModule:(t,r={})=>g(t,r,p),parseImportsExports:(t,r={})=>b(t,r,p)}}export{e as ParseError,u as createParser};
+import"./shared-stdj6se1.js";import"./shared-4wqe6a27.js";import"./shared-xyqvjc3m.js";import{e}from"./shared-jxkrk6hx.js";import"./shared-nbaaegmc.js";import{Ee}from"./shared-n0fpkmn8.js";import{U}from"./shared-rh41v5ez.js";import"./shared-2by923ar.js";import{T}from"./shared-artd3d80.js";import{k}from"./shared-hjcsmz9f.js";import{ee,kt}from"./shared-h6c4cer7.js";function u(o={}){let p=ee(o.typescript),s={typescript:p,entityNames:kt(o.entities)??Ee};return{parse:(t,r)=>U(t,r,s),parseModule:(t,r={})=>T(t,r,p),parseImportsExports:(t,r={})=>k(t,r,p)}}export{e as ParseError,u as createParser};

package/entities.js

@@ -1 +1 @@
-import"./shared-k5pfyxpa.js";import{x}from"./shared-3yc3kmnb.js";import{ht}from"./shared-fcgh2ks8.js";var p=ht(x);export{p as entities};
+import"./shared-n0fpkmn8.js";import{v}from"./shared-v0nj05q2.js";import{Tt}from"./shared-h6c4cer7.js";var p=Tt(v);export{p as entities};

package/index.d.ts

@@ -278,8 +278,7 @@ export interface ParseImportsExportsOptions {
 
 /**
  * Parses a Svelte component into svelte's modern AST, the same as
- * `parse(source, { modern: true })` from svelte/compiler. From svelte's
- * `Parser` constructor (`phases/1-parse/index.js`).
+ * `parse(source, { modern: true })` from svelte/compiler.
  *
  * Throws a {@link ParseError} on a syntax error.
  */
@@ -2019,13 +2018,197 @@ export declare function parseSections(source: string, options?: ParseOptions): A
  */
 export declare function isRunesMode(source: string): boolean;
 
+/** How a {@link Binding} is declared. */
+export type BindingKind = "import" | "var" | "let" | "const" | "using" | "function" | "class" | "enum" | "enum-member" | "namespace" | "param" | "catch" | "reactive" | "each" | "each-index" | "let-directive" | "snippet" | "snippet-param" | "const-tag" | "await-value" | "await-error";
+
+/** A name declared in a {@link Scope}. */
+export interface Binding {
+    readonly name: string;
+    /**
+     * What declares it: `"import"`, `"var"`, `"let"`, `"const"` (`{let}`
+     * and `{const}` tags included), `"using"`, `"function"`, `"class"`,
+     * `"enum"`, `"enum-member"`, `"namespace"`, `"param"`, `"catch"`,
+     * `"reactive"` (`x` in `$: x = ...` without a declaration of `x`),
+     * `"each"` and `"each-index"` (`item` and `i` in `{#each items as item,
+     * i}`), `"let-directive"`, `"snippet"` (its name), `"snippet-param"`,
+     * `"const-tag"` (`{@const}`), `"await-value"` and `"await-error"` (`{:then
+     * value}` and `{:catch error}`).
+     */
+    readonly kind: BindingKind;
+    /**
+     * The `Identifier` that declares it; `null` for an each block's index
+     * and `let:x` without a value, whose names are strings.
+     */
+    readonly node: Identifier | null;
+    /**
+     * The node that declares it: the import specifier, the
+     * `VariableDeclarator`, the function or class, the function a
+     * parameter belongs to, the `CatchClause`, the `LabeledStatement` of
+     * `$:`, the `EachBlock`, `LetDirective`, `SnippetBlock` or `AwaitBlock`,
+     * the enum, enum member or namespace, or `import a = b`.
+     */
+    readonly declaration: AST.SvelteNode;
+    /**
+     * What it starts as, as svelte's analyzer has it: a variable's
+     * initializer, the function or class, the `ImportDeclaration`, the
+     * `SnippetBlock` for a snippet's name, the `EachBlock` for an index,
+     * the right side of `$: x = ...`, an enum member's initializer. For a
+     * prop destructured from `$props()`, its default, without `$bindable`:
+     * `"md"` in `let { size = "md" } = $props()` or in `let { size =
+     * $bindable("md") } = $props()`. `null` otherwise.
+     */
+    readonly initial: AST.SvelteNode | null;
+    readonly scope: Scope;
+    /**
+     * Every use of it, in source order: reads, writes, and `$name`
+     * subscriptions if it's a store. Not the identifiers that declare it,
+     * but for `x` in `$: x = ...`, which declares `x` and writes it each
+     * time the statement runs.
+     */
+    readonly references: readonly Reference[];
+    /**
+     * The rune its declarator's initializer calls, such as `"$state"`,
+     * `"$state.raw"`, `"$derived"`, `"$derived.by"` or `"$props"`, unless
+     * a binding or a store shadows it; `null` otherwise.
+     */
+    readonly rune: string | null;
+    /**
+     * The name a parent passes it as, for a prop: `"class"` for `klass` in
+     * `let { class: klass } = $props()` and in `export { klass as class }`,
+     * `"size"` in `export let size`. `null` otherwise, including for `rest`
+     * in `let { a, ...rest } = $props()`.
+     */
+    readonly prop: string | null;
+}
+
+/** A use of a name. */
+export interface Reference {
+    /**
+     * The `Identifier`. For a name the AST holds only as a string, such as
+     * `Foo` in `<Foo.Bar>`, `a` in `use:a`, `transition:a`, `in:a`,
+     * `out:a` and `animate:a`, and `color` in `style:color`, a new
+     * `Identifier` with the name's `start` and `end`.
+     */
+    readonly node: Identifier;
+    /** The node that holds it. */
+    readonly parent: AST.SvelteNode;
+    /** The scope it's in. */
+    readonly scope: Scope;
+    /** What it refers to; `null` for a global, such as `window` or a rune. */
+    readonly binding: Binding | null;
+    /**
+     * Whether it reads the value: all but the target of a plain `=`, and
+     * every store subscription.
+     */
+    readonly reads: boolean;
+    /**
+     * Whether it assigns a new value: the target of `=`, `+=` and the like,
+     * `++` and `--`, `bind:`, or `for (a of b)`.
+     */
+    readonly writes: boolean;
+    /**
+     * Whether it changes a property of the value: `a` in `a.b = c`,
+     * `a.b++` and `bind:value={a.b}`.
+     */
+    readonly mutates: boolean;
+    /**
+     * Whether it's a store subscription: `$count` refers to `count`, and
+     * `$count = 1` mutates it.
+     */
+    readonly store: boolean;
+}
+
 /**
- * The fields of each node type that hold child nodes, in source order.
- * Typed against the AST, so a node type without an entry, or a key that
- * isn't one of its fields, fails typechecking. `tests/walk.test.ts` checks
- * the rest against the corpus: no field that holds a node is missing, and
- * children come in source order.
+ * The names a function, block, element or other node declares, and the
+ * scopes around it.
+ */
+export interface Scope {
+    /**
+     * The node that makes it, or `null` for a component's `<script>` or
+     * `<script module>` that isn't there.
+     */
+    readonly node: AST.SvelteNode | null;
+    readonly parent: Scope | null;
+    /** Its own bindings, by name, in the order they're declared. */
+    readonly declarations: ReadonlyMap<string, Binding>;
+    /**
+     * The binding `name` refers to here, declared in this scope or one
+     * around it; `null` if none does.
+     */
+    get(name: string): Binding | null;
+}
+
+/** What {@link analyzeScopes} found. */
+export interface Scopes {
+    /** The `<script module>`'s scope, or a module's. */
+    readonly module: Scope;
+    /** The `<script>`'s scope, inside `module`; a module's, for a module. */
+    readonly instance: Scope;
+    /**
+     * The scope `node` is in: for a function, the scope around it, while
+     * its parameters are in its own. `null` for a node in a type, in the
+     * `<style>` or outside the AST.
+     */
+    scopeOf(node: AST.SvelteNode): Scope | null;
+    /**
+     * The binding an `Identifier` declares or refers to; `null` for a
+     * global, and for a name that isn't a reference, such as a property
+     * key or a name in a type.
+     */
+    bindingOf(node: Identifier): Binding | null;
+    /**
+     * The use an `Identifier` is, with whether it reads, writes or
+     * mutates its binding or subscribes to it as a store; `null` for an
+     * `Identifier` that declares a binding or isn't a reference. A global's
+     * use has no binding.
+     */
+    referenceOf(node: Identifier): Reference | null;
+    /**
+     * The bindings of the scope `node` makes, by name; empty if it makes
+     * none. A function's are its parameters, and a function expression's
+     * name; its body's declarations are its body's.
+     */
+    declaredIn(node: AST.SvelteNode): ReadonlyMap<string, Binding>;
+}
+
+/**
+ * Finds every scope, binding and reference in a component, its scripts
+ * and its markup together, or in a module, as svelte's analyzer does:
+ * which declaration each name refers to, and where each binding is read,
+ * written or subscribed to.
+ *
+ * Besides JavaScript's scopes, it knows the markup's: `{#each items as
+ * item, i (key)}` declares `item` and `i` for the key and the body, a
+ * snippet its parameters, `{:then value}` and `{:catch error}` their
+ * names, `{@const}` a name for its whole fragment, and `let:` a name for
+ * the element, or for a component's default or named slot (`let:a={b}`
+ * declares `b`). Store subscriptions such as `$count` are uses of
+ * `count`, unless they're runes. `bind:` writes its target, and
+ * `$: x = ...` declares `x` if nothing else does. A binding records the
+ * rune that initializes it, such as `$state` or `$props`, and the name a
+ * prop is passed as.
+ *
+ * Names in TypeScript types aren't references, and types aren't
+ * declarations: `interface` and `type` declare nothing. A top-level
+ * snippet is declared in the markup's scope, as in svelte's analyzer, so
+ * a `<script>` that uses it refers to a global.
+ *
+ * ```ts
+ * import { parse } from "sveast";
+ * import { analyzeScopes } from "sveast/scope";
+ *
+ * const ast = parse(source);
+ * const scopes = analyzeScopes(ast);
+ * const size = scopes.instance.get("size");
+ * size?.prop; // "size", for `let { size } = $props()`
+ * size?.references.some((reference) => reference.writes || reference.mutates);
+ * ```
+ *
+ * It reads the AST but doesn't change it.
  */
+export declare function analyzeScopes(ast: AST.Root | Program): Scopes;
+
+/** The fields of each node type that hold child nodes, in source order. */
 export declare const visitorKeys: {
     readonly Root: readonly ["module", "instance", "fragment", "css"];
     readonly Script: readonly ["attributes", "content"];
@@ -2145,6 +2328,7 @@ export declare const visitorKeys: {
     readonly AwaitExpression: readonly ["argument"];
     readonly ImportExpression: readonly ["source", "options", "arguments"];
     readonly ChainExpression: readonly ["expression"];
+    readonly ParenthesizedExpression: readonly ["expression"];
     readonly MetaProperty: readonly ["meta", "property"];
     readonly ObjectPattern: readonly ["decorators", "properties", "typeAnnotation"];
     readonly ArrayPattern: readonly ["decorators", "elements", "typeAnnotation"];
@@ -2277,6 +2461,220 @@ export declare const markupVisitorKeys: {
     readonly SnippetBlock: readonly ["body"];
 };
 
+/**
+ * {@link visitorKeys} without TypeScript's types: a {@link walk} with it
+ * reaches every value and binding but no type annotation, type
+ * parameter, type argument, `implements` clause or type in `as` and
+ * `satisfies`, so an `Identifier` it reaches in a TypeScript node is
+ * never a type's name. It still enters a declaration that holds only
+ * types, such as `type T = ...`, `interface I {}` or an index signature,
+ * but not its children, and of `declare function f(): void` it visits
+ * only the name. The
+ * TypeScript nodes it enters children of hold values: `as`,
+ * `satisfies`, `<T>a`, `a!` and `a<T>` hold their expression, an enum
+ * its members, a namespace its body, `import a = b` and `export =` their
+ * value, and a parameter property its parameter.
+ */
+export declare const valueVisitorKeys: {
+    readonly FunctionDeclaration: readonly ["id", "params", "body"];
+    readonly FunctionExpression: readonly ["id", "params", "body"];
+    readonly ArrowFunctionExpression: readonly ["params", "body"];
+    readonly ClassDeclaration: readonly ["decorators", "id", "superClass", "body"];
+    readonly ClassExpression: readonly ["decorators", "id", "superClass", "body"];
+    readonly MethodDefinition: readonly ["decorators", "key", "value"];
+    readonly PropertyDefinition: readonly ["decorators", "key", "value"];
+    readonly Identifier: readonly ["decorators"];
+    readonly CallExpression: readonly ["callee", "arguments"];
+    readonly NewExpression: readonly ["callee", "arguments"];
+    readonly TaggedTemplateExpression: readonly ["tag", "quasi"];
+    readonly RestElement: readonly ["decorators", "argument"];
+    readonly ObjectPattern: readonly ["decorators", "properties"];
+    readonly ArrayPattern: readonly ["decorators", "elements"];
+    readonly TSTypeAnnotation: readonly [];
+    readonly TSTypeParameterDeclaration: readonly [];
+    readonly TSTypeParameterInstantiation: readonly [];
+    readonly TSTypeParameter: readonly [];
+    readonly TSArrayType: readonly [];
+    readonly TSTupleType: readonly [];
+    readonly TSNamedTupleMember: readonly [];
+    readonly TSOptionalType: readonly [];
+    readonly TSRestType: readonly [];
+    readonly TSUnionType: readonly [];
+    readonly TSIntersectionType: readonly [];
+    readonly TSConditionalType: readonly [];
+    readonly TSInferType: readonly [];
+    readonly TSParenthesizedType: readonly [];
+    readonly TSTypeOperator: readonly [];
+    readonly TSIndexedAccessType: readonly [];
+    readonly TSMappedType: readonly [];
+    readonly TSLiteralType: readonly [];
+    readonly TSTypeReference: readonly [];
+    readonly TSTypeQuery: readonly [];
+    readonly TSImportType: readonly [];
+    readonly TSTypeLiteral: readonly [];
+    readonly TSPropertySignature: readonly [];
+    readonly TSMethodSignature: readonly [];
+    readonly TSCallSignatureDeclaration: readonly [];
+    readonly TSConstructSignatureDeclaration: readonly [];
+    readonly TSFunctionType: readonly [];
+    readonly TSConstructorType: readonly [];
+    readonly TSIndexSignature: readonly [];
+    readonly TSTypePredicate: readonly [];
+    readonly TSInterfaceDeclaration: readonly [];
+    readonly TSInterfaceBody: readonly [];
+    readonly TSExpressionWithTypeArguments: readonly [];
+    readonly TSTypeAliasDeclaration: readonly [];
+    readonly TSNamespaceExportDeclaration: readonly [];
+    readonly TSDeclareFunction: readonly ["id"];
+    readonly TSDeclareMethod: readonly [];
+    readonly TSAsExpression: readonly ["expression"];
+    readonly TSSatisfiesExpression: readonly ["expression"];
+    readonly TSTypeAssertion: readonly ["expression"];
+    readonly TSInstantiationExpression: readonly ["expression"];
+    readonly Root: readonly ["module", "instance", "fragment", "css"];
+    readonly Script: readonly ["attributes", "content"];
+    readonly Fragment: readonly ["nodes"];
+    readonly Text: readonly [];
+    readonly Comment: readonly [];
+    readonly ExpressionTag: readonly ["expression"];
+    readonly HtmlTag: readonly ["expression"];
+    readonly ConstTag: readonly ["declaration"];
+    readonly DeclarationTag: readonly ["declaration"];
+    readonly DebugTag: readonly ["identifiers"];
+    readonly RenderTag: readonly ["expression"];
+    readonly AttachTag: readonly ["expression"];
+    readonly Attribute: readonly ["value"];
+    readonly SpreadAttribute: readonly ["expression"];
+    readonly AnimateDirective: readonly ["expression"];
+    readonly BindDirective: readonly ["expression"];
+    readonly ClassDirective: readonly ["expression"];
+    readonly LetDirective: readonly ["expression"];
+    readonly OnDirective: readonly ["expression"];
+    readonly StyleDirective: readonly ["value"];
+    readonly TransitionDirective: readonly ["expression"];
+    readonly UseDirective: readonly ["expression"];
+    readonly Component: readonly ["attributes", "fragment"];
+    readonly TitleElement: readonly ["attributes", "fragment"];
+    readonly SlotElement: readonly ["attributes", "fragment"];
+    readonly RegularElement: readonly ["attributes", "fragment"];
+    readonly SvelteBody: readonly ["attributes", "fragment"];
+    readonly SvelteBoundary: readonly ["attributes", "fragment"];
+    readonly SvelteComponent: readonly ["expression", "attributes", "fragment"];
+    readonly SvelteDocument: readonly ["attributes", "fragment"];
+    readonly SvelteElement: readonly ["tag", "attributes", "fragment"];
+    readonly SvelteFragment: readonly ["attributes", "fragment"];
+    readonly SvelteHead: readonly ["attributes", "fragment"];
+    readonly SvelteOptions: readonly ["attributes", "fragment"];
+    readonly SvelteSelf: readonly ["attributes", "fragment"];
+    readonly SvelteWindow: readonly ["attributes", "fragment"];
+    readonly IfBlock: readonly ["test", "consequent", "alternate"];
+    readonly EachBlock: readonly ["expression", "context", "key", "body", "fallback"];
+    readonly AwaitBlock: readonly ["expression", "pending", "value", "then", "error", "catch"];
+    readonly KeyBlock: readonly ["expression", "fragment"];
+    readonly SnippetBlock: readonly ["expression", "parameters", "body"];
+    readonly StyleSheet: readonly ["attributes", "children"];
+    readonly Rule: readonly ["prelude", "block"];
+    readonly Atrule: readonly ["block"];
+    readonly SelectorList: readonly ["children"];
+    readonly ComplexSelector: readonly ["children"];
+    readonly RelativeSelector: readonly ["combinator", "selectors"];
+    readonly Combinator: readonly [];
+    readonly TypeSelector: readonly [];
+    readonly IdSelector: readonly [];
+    readonly ClassSelector: readonly [];
+    readonly AttributeSelector: readonly [];
+    readonly PseudoElementSelector: readonly ["args"];
+    readonly PseudoClassSelector: readonly ["args"];
+    readonly Percentage: readonly [];
+    readonly Nth: readonly [];
+    readonly NestingSelector: readonly [];
+    readonly Block: readonly ["children"];
+    readonly Declaration: readonly [];
+    readonly Program: readonly ["body"];
+    readonly ExpressionStatement: readonly ["expression"];
+    readonly BlockStatement: readonly ["body"];
+    readonly StaticBlock: readonly ["body"];
+    readonly EmptyStatement: readonly [];
+    readonly DebuggerStatement: readonly [];
+    readonly WithStatement: readonly ["object", "body"];
+    readonly ReturnStatement: readonly ["argument"];
+    readonly LabeledStatement: readonly ["label", "body"];
+    readonly BreakStatement: readonly ["label"];
+    readonly ContinueStatement: readonly ["label"];
+    readonly IfStatement: readonly ["test", "consequent", "alternate"];
+    readonly SwitchStatement: readonly ["discriminant", "cases"];
+    readonly SwitchCase: readonly ["test", "consequent"];
+    readonly ThrowStatement: readonly ["argument"];
+    readonly TryStatement: readonly ["block", "handler", "finalizer"];
+    readonly CatchClause: readonly ["param", "body"];
+    readonly WhileStatement: readonly ["test", "body"];
+    readonly DoWhileStatement: readonly ["body", "test"];
+    readonly ForStatement: readonly ["init", "test", "update", "body"];
+    readonly ForInStatement: readonly ["left", "right", "body"];
+    readonly ForOfStatement: readonly ["left", "right", "body"];
+    readonly VariableDeclaration: readonly ["declarations"];
+    readonly VariableDeclarator: readonly ["id", "init"];
+    readonly ClassBody: readonly ["body"];
+    readonly Property: readonly ["decorators", "key", "value"];
+    readonly ThisExpression: readonly [];
+    readonly Super: readonly [];
+    readonly Literal: readonly [];
+    readonly PrivateIdentifier: readonly [];
+    readonly ArrayExpression: readonly ["elements"];
+    readonly ObjectExpression: readonly ["properties"];
+    readonly UnaryExpression: readonly ["argument"];
+    readonly UpdateExpression: readonly ["argument"];
+    readonly BinaryExpression: readonly ["left", "right"];
+    readonly LogicalExpression: readonly ["left", "right"];
+    readonly AssignmentExpression: readonly ["left", "right"];
+    readonly MemberExpression: readonly ["object", "property"];
+    readonly ConditionalExpression: readonly ["test", "consequent", "alternate"];
+    readonly SequenceExpression: readonly ["expressions"];
+    readonly TemplateLiteral: readonly ["quasis", "expressions"];
+    readonly TemplateElement: readonly [];
+    readonly SpreadElement: readonly ["argument"];
+    readonly YieldExpression: readonly ["argument"];
+    readonly AwaitExpression: readonly ["argument"];
+    readonly ImportExpression: readonly ["source", "options", "arguments"];
+    readonly ChainExpression: readonly ["expression"];
+    readonly ParenthesizedExpression: readonly ["expression"];
+    readonly MetaProperty: readonly ["meta", "property"];
+    readonly AssignmentPattern: readonly ["decorators", "left", "right"];
+    readonly ImportDeclaration: readonly ["specifiers", "source", "attributes"];
+    readonly ImportSpecifier: readonly ["imported", "local"];
+    readonly ImportDefaultSpecifier: readonly ["local"];
+    readonly ImportNamespaceSpecifier: readonly ["local"];
+    readonly ImportAttribute: readonly ["key", "value"];
+    readonly ExportNamedDeclaration: readonly ["declaration", "specifiers", "source", "attributes"];
+    readonly ExportSpecifier: readonly ["local", "exported"];
+    readonly ExportDefaultDeclaration: readonly ["declaration"];
+    readonly ExportAllDeclaration: readonly ["exported", "source", "attributes"];
+    readonly Decorator: readonly ["expression"];
+    readonly TSAnyKeyword: readonly [];
+    readonly TSBigIntKeyword: readonly [];
+    readonly TSBooleanKeyword: readonly [];
+    readonly TSNeverKeyword: readonly [];
+    readonly TSNullKeyword: readonly [];
+    readonly TSNumberKeyword: readonly [];
+    readonly TSObjectKeyword: readonly [];
+    readonly TSStringKeyword: readonly [];
+    readonly TSSymbolKeyword: readonly [];
+    readonly TSUndefinedKeyword: readonly [];
+    readonly TSUnknownKeyword: readonly [];
+    readonly TSVoidKeyword: readonly [];
+    readonly TSThisType: readonly [];
+    readonly TSQualifiedName: readonly ["left", "right"];
+    readonly TSEnumDeclaration: readonly ["id", "members"];
+    readonly TSEnumMember: readonly ["id", "initializer"];
+    readonly TSModuleDeclaration: readonly ["id", "body"];
+    readonly TSModuleBlock: readonly ["body"];
+    readonly TSImportEqualsDeclaration: readonly ["id", "moduleReference"];
+    readonly TSExternalModuleReference: readonly ["expression"];
+    readonly TSExportAssignment: readonly ["expression"];
+    readonly TSParameterProperty: readonly ["parameter"];
+    readonly TSNonNullExpression: readonly ["expression"];
+};
+
 /**
  * Return it from `enter` or `leave` to end the walk: no further `enter` or
  * `leave` calls, including `leave` on the node's ancestors.
@@ -2316,6 +2714,22 @@ export interface Visitor {
  */
 export declare function walk(node: AST.SvelteNode, visitor: Visitor, keys?: VisitorKeys): void;
 
+/**
+ * Calls `callback` with each of `node`'s child nodes in source order, as
+ * {@link walk} would visit them, with the field that holds the child and
+ * its index when the field is an array. Allocates nothing. `keys` is as
+ * in {@link walk}.
+ */
+export declare function forEachChild(node: AST.SvelteNode, callback: (child: AST.SvelteNode, key: string, index: number | null) => void, keys?: VisitorKeys): void;
+
+/**
+ * `node`'s child nodes in source order, as {@link walk} would visit them.
+ * The array is made on the first call for each node and `keys`, and the
+ * same one is returned after, so don't change it; a node that
+ * {@link walk} replaces later isn't in it. `keys` is as in {@link walk}.
+ */
+export declare function children(node: AST.SvelteNode, keys?: VisitorKeys): readonly AST.SvelteNode[];
+
 /**
  * The `Identifier` nodes a pattern binds, in source order: `a`, `c`, `d`,
  * `e` and `f` in `{ a, b: [c, ...d], e = 1, ...f }`. Not the property
@@ -2341,3 +2755,19 @@ export declare function extractIdentifiers(pattern: Pattern | TSParameterPropert
  * property, an enum's name, or the name or target of `import a = b`.
  */
 export declare function isReference(node: AST.SvelteNode, parent: AST.SvelteNode | null): boolean;
+
+/**
+ * The `{ line, column }` of `offset` in `text`, line from 1 and column
+ * from 0, as {@link createLocator}'s function gives it, without keeping
+ * a locator: the lines of the last 64 texts are kept, so calls for
+ * several files in any order cost a lookup each after the first.
+ *
+ * ```ts
+ * import { locate } from "sveast";
+ *
+ * `${file}:${locate(source, node.start).line}`;
+ * ```
+ */
+export declare function locate(text: string, offset: number): Position;
+
+export declare function skipTypeWrappers(node: AST.SvelteNode): AST.SvelteNode;

package/index.js

@@ -1 +1 @@
-import{isValidType as t}from"./is-valid-type.js";import{lexComponent as p,lexImportsExports as s,lexStrings as x}from"./lexer.js";import{parse as m}from"./parse.js";import{parseImportsExports as f}from"./parse-imports-exports.js";import{ParseError as a,parseModule as y}from"./parse-module.js";import{parseSections as S}from"./parse-sections.js";import{isRunesMode as c}from"./runes.js";import{createLocator as u,extractIdentifiers as E,isReference as P,markupVisitorKeys as O,SKIP as K,STOP as V,visitorKeys as k,walk as C}from"./walk.js";export{a as ParseError,K as SKIP,V as STOP,u as createLocator,E as extractIdentifiers,P as isReference,c as isRunesMode,t as isValidType,p as lexComponent,s as lexImportsExports,x as lexStrings,O as markupVisitorKeys,m as parse,f as parseImportsExports,y as parseModule,S as parseSections,k as visitorKeys,C as walk};
+import{isValidType as o}from"./is-valid-type.js";import{lexComponent as p,lexImportsExports as s,lexStrings as i}from"./lexer.js";import{parse as n}from"./parse.js";import{parseImportsExports as a}from"./parse-imports-exports.js";import{ParseError as f,parseModule as y}from"./parse-module.js";import{parseSections as l}from"./parse-sections.js";import{isRunesMode as L}from"./runes.js";import{analyzeScopes as E}from"./scope.js";import{children as K,createLocator as P,extractIdentifiers as O,forEachChild as V,isReference as g,locate as k,markupVisitorKeys as C,SKIP as T,STOP as h,skipTypeWrappers as v,valueVisitorKeys as M,visitorKeys as R,walk as w}from"./walk.js";export{f as ParseError,T as SKIP,h as STOP,E as analyzeScopes,K as children,P as createLocator,O as extractIdentifiers,V as forEachChild,g as isReference,L as isRunesMode,o as isValidType,p as lexComponent,s as lexImportsExports,i as lexStrings,k as locate,C as markupVisitorKeys,n as parse,a as parseImportsExports,y as parseModule,l as parseSections,v as skipTypeWrappers,M as valueVisitorKeys,R as visitorKeys,w as walk};

package/is-valid-type.js

@@ -1 +1 @@
-import{i}from"./shared-zd01zsyh.js";import{q}from"./shared-np5jnnrw.js";var a=new Set("abstract accessor arguments as asserts async await break case catch class const continue debugger declare default delete do else enum eval export extends false finally for function get global if implements import in infer instanceof interface intrinsic is keyof let module namespace new null of out override package private protected public readonly return satisfies set static super switch this throw true try type typeof unique var void while with yield".split(" ")),c=new Set("any bigint boolean false never null number object string symbol true undefined unknown void".split(" ")),d=new Set("get set new readonly static public private protected".split(" "));function u(t){return t>=97&&t<=122||t>=65&&t<=90||t===95||t===36}function o(t){return t>=48&&t<=57}function h(t){return u(t)||o(t)}class l{text;pos=0;constructor(t){this.text=t}readAll(){if(!this.type())return!1;return this.peek(),this.pos===this.text.length}peek(){let t=this.text,e=this.pos,s=t.charCodeAt(e);while(s===32||s===9)s=t.charCodeAt(++e);return this.pos=e,s}eat(t){if(this.peek()!==t.charCodeAt(0))return!1;return this.pos++,!0}word(){if(!u(this.peek()))return;let t=this.pos,e=t+1;while(h(this.text.charCodeAt(e)))e++;return this.pos=e,this.text.slice(t,e)}name(){let t=this.word();return t!==void 0&&!a.has(t)}string(){let t=this.peek();if(t!==34&&t!==39)return!1;let e=this.text;for(let s=this.pos+1;s<e.length;s++){let r=e.charCodeAt(s);if(r===t)return this.pos=s+1,!0;if(r===92||r===10||r===13||r===8232||r===8233)return!1}return!1}number(){let t=this.text,e=this.pos;if(t.charCodeAt(e)===45)e++;let s=e;while(o(t.charCodeAt(e)))e++;if(e===s||e-s>1&&t.charCodeAt(s)===48)return!1;if(t.charCodeAt(e)===46){let n=++e;while(o(t.charCodeAt(e)))e++;if(e===n)return!1}let r=t.charCodeAt(e);if(h(r)||r===46)return!1;return this.pos=e,!0}type(){if(this.peek()===40){let t=this.pos;if(this.functionType())return!0;this.pos=t}do do if(!this.operatorType())return!1;while(this.eat("&"));while(this.eat("|"));return!0}operatorType(){let t=this.pos;if(this.word()==="keyof")return this.operatorType();if(this.pos=t,!this.primaryType())return!1;while(this.eat("[")){if(this.eat("]"))continue;if(!this.type()||!this.eat("]"))return!1}return!0}primaryType(){let t=this.peek();if(t===40)return this.pos++,this.type()&&this.eat(")");if(t===123)return this.objectType();if(t===91)return this.tupleType();if(t===34||t===39)return this.string();if(t===45||o(t))return this.number();let e=this.word();if(e===void 0)return!1;if(e==="typeof")return this.typeQuery();if(e==="import")return this.importType(!0);if(c.has(e)){let s=this.peek();return s!==46&&s!==60}if(a.has(e))return!1;while(this.eat("."))if(this.word()===void 0)return!1;return!this.eat("<")||this.typeArguments()}typeArguments(){do if(!this.type())return!1;while(this.eat(","));return this.eat(">")}typeQuery(){let t=this.pos;if(this.word()==="import")return this.importType(!1);this.pos=t;do if(!this.name())return!1;while(this.eat("."));return!0}importType(t){if(!this.eat("(")||!this.string()||!this.eat(")"))return!1;while(this.eat("."))if(!this.name())return!1;return!t||!this.eat("<")||this.typeArguments()}objectType(){this.pos++;while(!this.eat("}")){if(!this.typeMember())return!1;if(!this.eat(";")&&!this.eat(",")&&this.peek()!==125)return!1}return!0}typeMember(){let t=this.peek();if(this.eat("[")){let e=this.peek();if(e===34||e===39){if(!this.string()||!this.eat("]"))return!1}else return this.name()&&this.eat(":")&&this.type()&&this.eat("]")&&this.eat(":")&&this.type()}else if(t===34||t===39){if(!this.string())return!1}else{let e=this.word();if(e===void 0||d.has(e))return!1}return this.eat("?"),this.eat(":")&&this.type()}tupleType(){if(this.pos++,this.eat("]"))return!0;do if(!this.type())return!1;while(this.eat(","));return this.eat("]")}functionType(){if(this.pos++,!this.eat(")")){let t=new Set;for(;;){this.peek();let e=this.text.startsWith("...",this.pos);if(e)this.pos+=3;let s=this.word();if(s===void 0||a.has(s)||t.has(s))return!1;if(t.add(s),!e)this.eat("?");if(!this.eat(":")||!this.type())return!1;if(e||!this.eat(","))break}if(!this.eat(")"))return!1}if(this.peek(),!this.text.startsWith("=>",this.pos))return!1;return this.pos+=2,this.type()}}function f(t){return new l(t).readAll()}var y=i.extend(q);function C(t,e={}){return f(t)||m(t,e.inline??!1)}function m(t,e){let s=!1,r=new y(e?{ecmaVersion:16,sourceType:"module",onComment:(n,b,T,p)=>{if(!n&&p===t.length)s=!0}}:{ecmaVersion:16,sourceType:"module"},t);try{return r.parseWholeType(),!s}catch(n){if(n instanceof SyntaxError)return!1;throw n}}export{C as isValidType,m as parsesAsType};
+import{r}from"./shared-xyqvjc3m.js";import{z}from"./shared-c9gzmr05.js";var a=new Set("abstract accessor arguments as asserts async await break case catch class const continue debugger declare default delete do else enum eval export extends false finally for function get global if implements import in infer instanceof interface intrinsic is keyof let module namespace new null of out override package private protected public readonly return satisfies set static super switch this throw true try type typeof unique var void while with yield".split(" ")),c=new Set("any bigint boolean false never null number object string symbol true undefined unknown void".split(" ")),d=new Set("get set new readonly static public private protected".split(" "));function u(t){return t>=97&&t<=122||t>=65&&t<=90||t===95||t===36}function o(t){return t>=48&&t<=57}function h(t){return u(t)||o(t)}class l{text;pos=0;constructor(t){this.text=t}readAll(){if(!this.type())return!1;return this.peek(),this.pos===this.text.length}peek(){let t=this.text,e=this.pos,s=t.charCodeAt(e);while(s===32||s===9)s=t.charCodeAt(++e);return this.pos=e,s}eat(t){if(this.peek()!==t.charCodeAt(0))return!1;return this.pos++,!0}word(){let t=this.pos;return this.skipWord()?this.text.slice(t,this.pos):void 0}skipWord(){if(!u(this.peek()))return!1;let t=this.pos+1;while(h(this.text.charCodeAt(t)))t++;return this.pos=t,!0}keyword(t){this.peek();let e=this.pos+t.length;if(!this.text.startsWith(t,this.pos)||h(this.text.charCodeAt(e)))return!1;return this.pos=e,!0}name(){let t=this.word();return t!==void 0&&!a.has(t)}string(){let t=this.peek();if(t!==34&&t!==39)return!1;let e=this.text;for(let s=this.pos+1;s<e.length;s++){let i=e.charCodeAt(s);if(i===t)return this.pos=s+1,!0;if(i===92||i===10||i===13||i===8232||i===8233)return!1}return!1}number(){let t=this.text,e=this.pos;if(t.charCodeAt(e)===45)e++;let s=e;while(o(t.charCodeAt(e)))e++;if(e===s||e-s>1&&t.charCodeAt(s)===48)return!1;if(t.charCodeAt(e)===46){let n=++e;while(o(t.charCodeAt(e)))e++;if(e===n)return!1}let i=t.charCodeAt(e);if(h(i)||i===46)return!1;return this.pos=e,!0}type(){if(this.peek()===40){let t=this.pos;if(this.functionType())return!0;this.pos=t}do do if(!this.operatorType())return!1;while(this.eat("&"));while(this.eat("|"));return!0}operatorType(){if(this.keyword("keyof"))return this.operatorType();if(!this.primaryType())return!1;while(this.eat("[")){if(this.eat("]"))continue;if(!this.type()||!this.eat("]"))return!1}return!0}primaryType(){let t=this.peek();if(t===40)return this.pos++,this.type()&&this.eat(")");if(t===123)return this.objectType();if(t===91)return this.tupleType();if(t===34||t===39)return this.string();if(t===45||o(t))return this.number();let e=this.word();if(e===void 0)return!1;if(e==="typeof")return this.typeQuery();if(e==="import")return this.importType(!0);if(c.has(e)){let s=this.peek();return s!==46&&s!==60}if(a.has(e))return!1;while(this.eat("."))if(!this.skipWord())return!1;return!this.eat("<")||this.typeArguments()}typeArguments(){do if(!this.type())return!1;while(this.eat(","));return this.eat(">")}typeQuery(){if(this.keyword("import"))return this.importType(!1);do if(!this.name())return!1;while(this.eat("."));return!0}importType(t){if(!this.eat("(")||!this.string()||!this.eat(")"))return!1;while(this.eat("."))if(!this.name())return!1;return!t||!this.eat("<")||this.typeArguments()}objectType(){this.pos++;while(!this.eat("}")){if(!this.typeMember())return!1;if(!this.eat(";")&&!this.eat(",")&&this.peek()!==125)return!1}return!0}typeMember(){let t=this.peek();if(this.eat("[")){let e=this.peek();if(e===34||e===39){if(!this.string()||!this.eat("]"))return!1}else return this.name()&&this.eat(":")&&this.type()&&this.eat("]")&&this.eat(":")&&this.type()}else if(t===34||t===39){if(!this.string())return!1}else{let e=this.word();if(e===void 0||d.has(e))return!1}return this.eat("?"),this.eat(":")&&this.type()}tupleType(){if(this.pos++,this.eat("]"))return!0;do if(!this.type())return!1;while(this.eat(","));return this.eat("]")}functionType(){if(this.pos++,!this.eat(")")){let t=new Set;for(;;){this.peek();let e=this.text.startsWith("...",this.pos);if(e)this.pos+=3;let s=this.word();if(s===void 0||a.has(s)||t.has(s))return!1;if(t.add(s),!e)this.eat("?");if(!this.eat(":")||!this.type())return!1;if(e||!this.eat(","))break}if(!this.eat(")"))return!1}if(this.peek(),!this.text.startsWith("=>",this.pos))return!1;return this.pos+=2,this.type()}}function f(t){return new l(t).readAll()}var y=r.extend(z);function k(t,e={}){return f(t)||m(t,e.inline??!1)}function m(t,e){let s=!1,i=new y(e?{ecmaVersion:16,sourceType:"module",onComment:(n,b,A,p)=>{if(!n&&p===t.length)s=!0}}:{ecmaVersion:16,sourceType:"module"},t);try{return i.parseWholeType(),!s}catch(n){if(n instanceof SyntaxError)return!1;throw n}}export{k as isValidType,m as parsesAsType};