@doenet/v06-to-v07 0.7.26-dev.571 → 0.7.26-dev.573

package/apply-assign-name-renames.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from 'unified';
+import { DastRoot } from '../packages/parser/dist';
+import { AssignNamesContext } from './assign-names/context';
+/**
+ * Rewrite every reference to a v0.6 `assignNames` name, using the renames collected by
+ * `upgradeCollectElement`, `upgradeMapElement` and `upgradeAssignNames`.
+ *
+ * This runs once, after all of them, so that a reference is rewritten exactly once no
+ * matter which plugin claimed the name.
+ */
+export declare const applyAssignNameRenames: Plugin<[
+    AssignNamesContext
+], DastRoot, DastRoot>;
+//# sourceMappingURL=apply-assign-name-renames.d.ts.map

package/apply-assign-name-renames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-assign-name-renames.d.ts","sourceRoot":"","sources":["../src/apply-assign-name-renames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACvC;IAAC,kBAAkB;CAAC,EACpB,QAAQ,EACR,QAAQ,CAKX,CAAC"}

package/assign-names/apply-renames.d.ts

@@ -0,0 +1,21 @@
+import { DastMacroPathPart, DastRoot } from '../../packages/parser/dist';
+import { VFile } from 'vfile';
+import { RenameRegistry } from './rename-registry';
+import { AssignNamesContext } from './context';
+/**
+ * Rewrite every reference to a v0.6 `assignNames` token into the v0.7 indexed path
+ * registered for it.
+ *
+ * Unlike the per-plugin passes this replaces, it descends into attribute values, macro
+ * path indices and function-macro arguments, and it preserves indices the author already
+ * wrote (`$a[2]` becomes `$s[1][2]`, not `$s[1]`).
+ */
+export declare function applyRefRenames(tree: DastRoot, registry: RenameRegistry, file: VFile, context: AssignNamesContext): void;
+/**
+ * Parse the value of a dollar-less reference attribute into a path.
+ *
+ * A hyphenated name can only be written inside `$(...)`: `$foo-bar` is a subtraction. The
+ * bare form is tried first so that everything else parses exactly as it always has.
+ */
+export declare function parseReferencePath(value: string): DastMacroPathPart[];
+//# sourceMappingURL=apply-renames.d.ts.map

package/assign-names/apply-renames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-renames.d.ts","sourceRoot":"","sources":["../../src/assign-names/apply-renames.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,iBAAiB,EACjB,QAAQ,EAGX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAoB,MAAM,WAAW,CAAC;AAmBjE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,kBAAkB,QAwC9B;AAwID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAarE"}

package/assign-names/break-into-pieces.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A parsed `assignNames` value. A string is a name assigned to a replacement; a nested
+ * array means "descend into that replacement and assign these names to *its* replacements".
+ */
+export type NamePieces = (string | NamePieces)[];
+export type BreakResult = {
+    success: true;
+    pieces: NamePieces;
+} | {
+    success: false;
+};
+/**
+ * Port of v0.6's `breakStringInPiecesBySpacesOrParens`
+ * (`utils/serializedStateProcessing.js`). Splits an `assignNames` value on whitespace,
+ * with parentheses creating nested groups.
+ *
+ * ```
+ * "a b"           -> ["a", "b"]
+ * "(a b) (c d)"   -> [["a", "b"], ["c", "d"]]
+ * "((x)) ((y))"   -> [[["x"]], [["y"]]]
+ * "(a"            -> { success: false }
+ * ```
+ *
+ * The quirks are deliberate and match v0.6 exactly, since the documents being converted
+ * were authored against them: unbalanced parentheses fail outright rather than falling
+ * back to whitespace splitting, and empty groups are dropped.
+ */
+export declare function breakStringInPiecesBySpacesOrParens(string: string): BreakResult;
+/**
+ * The first plain name in `pieces`, in document order, descending into nested groups.
+ * Returns `undefined` if there are no names at all.
+ */
+export declare function firstLeafName(pieces: NamePieces): string | undefined;
+//# sourceMappingURL=break-into-pieces.d.ts.map

package/assign-names/break-into-pieces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"break-into-pieces.d.ts","sourceRoot":"","sources":["../../src/assign-names/break-into-pieces.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,CAAC;AAEjD,MAAM,MAAM,WAAW,GACnB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mCAAmC,CAC/C,MAAM,EAAE,MAAM,GACf,WAAW,CAkEb;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAWpE"}

package/assign-names/composite-info.d.ts

@@ -0,0 +1,61 @@
+import { DastElement } from '../../packages/parser/dist';
+import { VFile } from 'vfile';
+import { PositionMap } from './register-assign-names';
+export type CompositeSpec = {
+    /** Canonical v0.7 spelling, used for generated names and messages. */
+    name: string;
+    /**
+     * How to tell whether the composite produces exactly one replacement, which is what
+     * makes the `assignNames="a"` -> `name="a"` shortcut safe.
+     */
+    count: {
+        kind: "always-one";
+    } | {
+        kind: "attr";
+        attr: string;
+    } | {
+        kind: "unknown";
+    };
+    /**
+     * The child element that is a transparent wrapper around a group of replacements.
+     * v0.7 flattens these, so names inside them sit one index deeper.
+     */
+    grouping?: {
+        childName: string;
+        alsoMatch?: string[];
+    };
+    /** The element itself has no v0.7 equivalent; warn while still fixing references. */
+    noV07Equivalent?: boolean;
+};
+/**
+ * The v0.6 composites that accept `assignNames` and are not already owned by another
+ * plugin. `copy`, `collect`, `map` and `customAttribute` are deliberately absent: they are
+ * handled by `copySourceToExtendOrCopy`/`upgradeCopySyntax`, `upgradeCollectElement`,
+ * `upgradeMapElement` and `upgradeModuleElement` respectively.
+ */
+export declare const COMPOSITES: Record<string, CompositeSpec>;
+export declare function lookupComposite(node: DastElement): CompositeSpec | undefined;
+/**
+ * Whether the composite provably produces a single replacement. When it does, a bare
+ * `$name` reference auto-flattens to that replacement, so `assignNames="a"` can simply
+ * become `name="a"` with no reference rewriting at all.
+ */
+export declare function producesSingleReplacement(node: DastElement, spec: CompositeSpec): boolean;
+export declare function findAttribute(node: DastElement, attrName: string): import('../../packages/parser/dist').DastAttribute | undefined;
+/**
+ * Build a {@link PositionMap} accounting for the fact that v0.6 skipped bare text when
+ * handing out `assignNames`, while v0.7's `[i]` counts every replacement.
+ *
+ * Only the level *inside* a transparent `<case>`/`<option>` wrapper can be affected, since
+ * that is the only level whose members are authored children rather than generated
+ * replacements. Returns `undefined` (meaning "identity") when no branch mixes bare text
+ * with components, which is the overwhelmingly common case.
+ */
+export declare function makePositionMap(node: DastElement, spec: CompositeSpec, file: VFile): PositionMap | undefined;
+/**
+ * The `<map>` counterpart of {@link makePositionMap}: its `<template>` is the single
+ * branch, and its children sit at the same depth as an `<option>`/`<case>`'s do — one
+ * index for the iteration, then one for the position within it.
+ */
+export declare function makeTemplatePositionMap(template: DastElement, node: DastElement, file: VFile): PositionMap | undefined;
+//# sourceMappingURL=composite-info.d.ts.map

package/assign-names/composite-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-info.d.ts","sourceRoot":"","sources":["../../src/assign-names/composite-info.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EAId,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,MAAM,aAAa,GAAG;IACxB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,KAAK,EACC;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,GACtB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAC9B;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACvD,qFAAqF;IACrF,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CA4CpD,CAAC;AAEF,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,aAAa,GAAG,SAAS,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACrC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,aAAa,GACpB,OAAO,CAeT;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,sDAIhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,KAAK,GACZ,WAAW,GAAG,SAAS,CAqBzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,KAAK,GACZ,WAAW,GAAG,SAAS,CAEzB"}

package/assign-names/context.d.ts

@@ -0,0 +1,103 @@
+import { DastElement, DastRoot, DastRootV6 } from '../../packages/parser/dist';
+import { NamePieces } from './break-into-pieces';
+import { RenameRegistry } from './rename-registry';
+import { UniqueNameFactory } from '../utils';
+import { VFile } from 'vfile';
+/**
+ * Per-document state shared by every plugin that consumes `assignNames`, so that all of
+ * them contribute to one registry and hand out names from one pool.
+ */
+export type AssignNamesContext = {
+    registry: RenameRegistry;
+    uniqueName: UniqueNameFactory;
+    /** Names carried by a `name=` attribute, used to detect shadowing. */
+    existingNames: Set<string>;
+    /**
+     * Assigned names that have already been promoted to some composite's `name`. Two
+     * composites can carry the same `assignNames` token, and only one of them can end up
+     * with the bare name.
+     *
+     * This pool is deliberately document-wide, which is stricter than v0.7 requires:
+     * v0.7 resolves a name by searching outwards from the reference, so two components
+     * with the same name are fine as long as they sit under different parents, and a
+     * reference that could see both is the only thing that fails (`NonUniqueReferent` in
+     * `ref_resolve`). Being strict costs a generated name in the handful of places where
+     * an assigned name is already used elsewhere, and buys output that cannot be
+     * ambiguous however the references are written. Relaxing it to "taken only by a
+     * sibling" is a deliberate design change, not an oversight.
+     */
+    claimedNames: Set<string>;
+    /**
+     * The elements that carried `newNamespace`, recorded before that attribute is
+     * removed. Only these were namespaces in v0.6, so only these are boundaries when
+     * working out which of two same-named assignments a reference meant.
+     *
+     * The value is how the namespace appears in a reference path: its `name`, or — for a
+     * namespace without one, such as the `<template newNamespace>` of a `<map>` — a
+     * stand-in that no written path can match. An unnamed namespace cannot be reached
+     * from outside, but it still keeps its contents apart from a sibling's.
+     */
+    namespaceElements: WeakMap<DastElement, string>;
+    /**
+     * For each name carried by a `name=` attribute, the v0.6 namespaces it sat in,
+     * outermost first — the same shape `namespaceChainOf` produces.
+     *
+     * {@link existingNames} answers "can anything still be called this?", which after
+     * flattening is a question about the whole document. This answers the different
+     * question of whether a reference written somewhere was already about a real
+     * component, which v0.6 resolved per namespace.
+     */
+    existingNameScopes: Map<string, string[][]>;
+};
+export declare function createAssignNamesContext(tree: DastRoot | DastRootV6): AssignNamesContext;
+/**
+ * Whether a real component called `name` sits in the very namespace `ancestorNames`
+ * names — the only place a bare reference written there would have found one instead of
+ * an assigned name, since v0.6 let a nearer assignment shadow an outer component.
+ */
+export declare function nameTakenInScope(context: AssignNamesContext, name: string, ancestorNames: string[] | undefined): boolean;
+/**
+ * Decide what the v0.7 `name` of a composite carrying `assignNames` should be.
+ *
+ * Preference order:
+ *  1. the `name` it already has;
+ *  2. the first assigned name, so the author's own vocabulary survives
+ *     (`assignNames="a b"` becomes `name="a"`, with `$a` -> `$a[1]`, `$b` -> `$a[2]`);
+ *  3. a generated unique name, when the first assigned name is not a legal v0.7 name,
+ *     already belongs to some other component, or has already been claimed this way.
+ */
+export declare function chooseCompositeName(node: DastElement, pieces: NamePieces, fallbackBase: string, context: AssignNamesContext, file?: VFile): string;
+/**
+ * Give `node` the name `name` and drop its `assignNames`.
+ *
+ * When there is no existing `name` attribute, the `assignNames` attribute is renamed in
+ * place so that attribute order (and therefore the shape of the converted source) is
+ * preserved.
+ */
+export declare function setCompositeName(node: DastElement, name: string): void;
+/**
+ * The value of an element's `assignNames` attribute, or `undefined` if it has none.
+ */
+export declare function readAssignNames(node: DastElement): string | undefined;
+/**
+ * Drop an `assignNames` attribute. v0.7 ignores it, but leaving it in the output trips
+ * schema validation and makes "did this document convert?" impossible to grep for.
+ */
+export declare function deleteAssignNames(node: DastElement): void;
+/**
+ * The `name`s of the elements enclosing a composite, outermost first.
+ *
+ * `visit` and `visitAll` both report parents nearest-first, which is the opposite of how
+ * a reference path reads, so the chain is reversed here. Elements without a name are
+ * skipped: they were never addressable, so a reference could not have mentioned them.
+ */
+export declare function namespaceChainOf(parents: DastElement[], context: AssignNamesContext): string[];
+/**
+ * Record that `to` now stands where `from` stood, so it keeps its namespace.
+ *
+ * `<map>` over a `<sequence>` becomes a `<repeatForSequence>` built from the sequence
+ * element, which throws away the `<template>` — and the template is what carried
+ * `newNamespace`. Without this the names assigned inside it would look top-level.
+ */
+export declare function inheritNamespace(from: DastElement, to: DastElement, context: AssignNamesContext): void;
+//# sourceMappingURL=context.d.ts.map

package/assign-names/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/assign-names/context.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,QAAQ,EACR,UAAU,EAIb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,UAAU,EAAiB,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,cAAc,EAA4B,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EACH,iBAAiB,EAGpB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAG9B;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,sEAAsE;IACtE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B;;;;;;;;;;;;;OAaG;IACH,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;;OASG;IACH,iBAAiB,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAChD;;;;;;;;OAQG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;CAC/C,CAAC;AAEF,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAC5B,kBAAkB,CA6DpB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,GAAG,SAAS,GACpC,OAAO,CAWT;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,CAAC,EAAE,KAAK,GACb,MAAM,CAgCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,QA6B/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAMrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,QAKlD;AAQD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC5B,OAAO,EAAE,WAAW,EAAE,EACtB,OAAO,EAAE,kBAAkB,GAC5B,MAAM,EAAE,CAYV;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,kBAAkB,QAM9B"}

package/assign-names/prop-access-parts.d.ts

@@ -0,0 +1,14 @@
+import { DastElement, DastMacroPathPart } from '../../packages/parser/dist';
+/** Record that `part` was written after a `.`, so it names a prop and not a component. */
+export declare function markAsPropAccess(part: DastMacroPathPart): void;
+/** Whether `part` was written after a `.`. See {@link markAsPropAccess}. */
+export declare function isPropAccess(part: DastMacroPathPart): boolean;
+/**
+ * Record that the parts at `positions` in this attribute's path were written after a `.`.
+ */
+export declare function markRawPropPositions(node: DastElement, attrName: string, positions: number[]): void;
+/**
+ * Put the marks recorded by {@link markRawPropPositions} back on a freshly parsed path.
+ */
+export declare function restoreRawPropPositions(node: DastElement, attrName: string, path: DastMacroPathPart[]): void;
+//# sourceMappingURL=prop-access-parts.d.ts.map

package/assign-names/prop-access-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-access-parts.d.ts","sourceRoot":"","sources":["../../src/assign-names/prop-access-parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAoBhE,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,QAEvD;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAE7D;AAeD;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EAAE,QAQtB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,iBAAiB,EAAE,QAY5B"}

package/assign-names/register-assign-names.d.ts

@@ -0,0 +1,38 @@
+import { VFile } from 'vfile';
+import { RenameOrigin, RenameRegistry } from './rename-registry';
+/**
+ * Translates a v0.6 nesting position into the v0.7 positional index.
+ *
+ * v0.6 skipped primitive (bare string) replacements when handing out `assignNames`,
+ * whereas v0.7's `[i]` counts every replacement including text. When they differ, the
+ * caller supplies a map. `depth` is 1-based (1 is the composite's own replacements).
+ */
+/**
+ * Maps an ordinal to the v0.7 index at that depth, or `undefined` when v0.6's ordinal
+ * named nothing there — see `makePositionMap`.
+ */
+export type PositionMap = (depth: number, ordinal: number) => number | undefined;
+export type RegisterAssignNamesArgs = {
+    /** The raw `assignNames` attribute value. */
+    assignNamesValue: string;
+    /** The v0.7 `name` the composite will carry. */
+    compositeName: string;
+    registry: RenameRegistry;
+    origin: RenameOrigin;
+    file: VFile;
+    positionMap?: PositionMap;
+};
+/**
+ * Register every name in a v0.6 `assignNames` value against the v0.7 indexed path that
+ * replaces it.
+ *
+ * A leaf name at nested position `(p1 … pk)` becomes `$<compositeName>[p1]…[pk]`, which is
+ * how v0.7 addresses the replacement that v0.6 would have given that name. See the
+ * conversion notes in `upgrade-assign-names.ts` for why this single rule covers every
+ * composite.
+ *
+ * Returns `false` (having registered nothing and emitted a message) if the value has
+ * unbalanced parentheses.
+ */
+export declare function registerAssignNames({ assignNamesValue, compositeName, registry, origin, file, positionMap, }: RegisterAssignNamesArgs): boolean;
+//# sourceMappingURL=register-assign-names.d.ts.map

package/assign-names/register-assign-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-assign-names.d.ts","sourceRoot":"","sources":["../../src/assign-names/register-assign-names.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAK9B,OAAO,EACH,YAAY,EACZ,cAAc,EAGjB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;GAMG;AACH;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,KACd,MAAM,GAAG,SAAS,CAAC;AAIxB,MAAM,MAAM,uBAAuB,GAAG;IAClC,6CAA6C;IAC7C,gBAAgB,EAAE,MAAM,CAAC;IACzB,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,cAAc,CAAC;IACzB,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,CAAC,EAAE,WAAW,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,WAAiC,GACpC,EAAE,uBAAuB,GAAG,OAAO,CAoEnC"}

package/assign-names/register-composite.d.ts

@@ -0,0 +1,26 @@
+import { DastElement } from '../../packages/parser/dist';
+import { VFile } from 'vfile';
+import { AssignNamesContext } from './context';
+import { PositionMap } from './register-assign-names';
+/**
+ * Parse an element's `assignNames`, pick the v0.7 name the composite will carry, and
+ * register the indexed path that replaces each assigned name.
+ *
+ * Returns the chosen name, or `undefined` when the value names nothing — either because
+ * it could not be parsed (in which case a message has been recorded) or because it parsed
+ * to no names at all, as `assignNames="()"` does. Nothing is registered in either case.
+ * The caller is responsible for putting the name on the element — `<map>` puts it on the
+ * `<repeat>` it produces rather than on the element that carried `assignNames`.
+ */
+export declare function registerCompositeAssignNames({ node, assignNamesValue, fallbackBase, ancestorNames, context, file, positionMap, }: {
+    node: DastElement;
+    assignNamesValue: string;
+    /** Base name to generate from when the assigned names cannot be reused. */
+    fallbackBase: string;
+    /** See `RenameOrigin.ancestorNames`. */
+    ancestorNames?: string[];
+    context: AssignNamesContext;
+    file: VFile;
+    positionMap?: PositionMap;
+}): string | undefined;
+//# sourceMappingURL=register-composite.d.ts.map

package/assign-names/register-composite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-composite.d.ts","sourceRoot":"","sources":["../../src/assign-names/register-composite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAK9B,OAAO,EAAE,kBAAkB,EAAuB,MAAM,WAAW,CAAC;AACpE,OAAO,EAAE,WAAW,EAAuB,MAAM,yBAAyB,CAAC;AAE3E;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,EACzC,IAAI,EACJ,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,OAAO,EACP,IAAI,EACJ,WAAW,GACd,EAAE;IACC,IAAI,EAAE,WAAW,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,CAAC,EAAE,WAAW,CAAC;CAC7B,GAAG,MAAM,GAAG,SAAS,CA2CrB"}

package/assign-names/rename-registry.d.ts

@@ -0,0 +1,90 @@
+import { DastElement, DastMacroPathPart } from '../../packages/parser/dist';
+import { VFile } from 'vfile';
+/**
+ * A name is a legal v0.7 component name *and* can be referenced.
+ *
+ * A hyphen is allowed. `$a-b` would parse as a subtraction, but the parenthesized form
+ * `$(a-b)` does not, and that is the only form v0.6 could reference such a name with
+ * either. `toXml` re-adds the parentheses around any path part containing a hyphen, so
+ * `$(a-b[1])` round-trips.
+ */
+export declare const VALID_REFERENCEABLE_NAME: RegExp;
+export declare function isValidReferenceableName(name: string): boolean;
+export type RenameOrigin = {
+    /** The element that carried the `assignNames` attribute; used in messages. */
+    elementName: string;
+    /**
+     * The element that ends up carrying the new name. A reference written *on* that
+     * element cannot mean the name it is about to take — `<copy source="../x0"
+     * assignNames="x0">` reaches out of its namespace for the thing it copies — so
+     * renames from this origin are not applied there.
+     */
+    element?: DastElement;
+    position?: DastElement["position"];
+    /**
+     * The `name`s of the elements enclosing the composite, outermost first.
+     *
+     * v0.6 namespaces meant the same assigned name could appear more than once in a
+     * document, and a reference said which it meant by writing the namespace in front of
+     * it (`$(g2/a)`). Flattening the namespaces away loses that, so it is recorded here
+     * and matched against the front of the reference path.
+     */
+    ancestorNames?: string[];
+};
+export type RenameTarget = {
+    /**
+     * The path parts that replace a matched path part. Always length 1 in practice, but
+     * kept as an array so the splice site reads the same as the existing plugins.
+     *
+     * `undefined` means the name was claimed as a composite's v0.7 `name`, so references
+     * to it already resolve and must be left exactly as the author wrote them. Such an
+     * entry exists only so that a second composite assigning the same name is detected.
+     */
+    replacement?: DastMacroPathPart[];
+    origin: RenameOrigin;
+};
+/**
+ * Build the DAST for a path part with a chain of literal indices.
+ *
+ * `makeIndexedPathPart("s", [1, 2])` is the DAST for `s[1][2]`.
+ */
+export declare function makeIndexedPathPart(name: string, indices: number[]): DastMacroPathPart;
+/**
+ * Collects every `assignNames` token in a document and the v0.7 indexed path that
+ * replaces it. A single registry is shared by all the plugins that consume `assignNames`
+ * so that a reference is rewritten exactly once, no matter which plugin claimed the name.
+ */
+export declare class RenameRegistry {
+    _renames: Map<string, RenameTarget[]>;
+    _matched: Set<string>;
+    /** Names carried by a `name=` attribute somewhere in the document. */
+    _existingNames: ReadonlySet<string>;
+    constructor(existingNames?: ReadonlySet<string>);
+    /**
+     * Register that `oldName` should be replaced by `replacement` wherever it appears in
+     * a macro path. The first registration of a name wins; a later one warns.
+     *
+     * Pass `undefined` for `replacement` to claim the name without rewriting anything,
+     * which is what a composite that simply took the assigned name as its own `name`
+     * needs: references already resolve, but a later composite assigning the same name
+     * must not silently redirect them.
+     */
+    register(oldName: string, replacement: DastMacroPathPart[] | undefined, origin: RenameOrigin, file: VFile): void;
+    /**
+     * The rename for `name`, chosen by which of them the reference is reaching into.
+     *
+     * `precedingNames` are the path parts written before it, so `$g2.a` looks up `a` with
+     * `["g2"]`. The registration whose enclosing names are the longest match at the end of
+     * that wins; one recorded with no enclosing names matches anything, which is what
+     * keeps an unscoped document behaving exactly as before.
+     */
+    get(name: string, precedingNames?: string[], 
+    /** Skip renames that would point a reference at the element carrying it. */
+    writtenOn?: DastElement): RenameTarget | undefined;
+    /** Whether `name` is registered *and* some registration rewrites references to it. */
+    hasReplacement(name: string): boolean;
+    get size(): number;
+    /** Registered names that were never referenced anywhere in the document. */
+    unused(): string[];
+}
+//# sourceMappingURL=rename-registry.d.ts.map

package/assign-names/rename-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-registry.d.ts","sourceRoot":"","sources":["../../src/assign-names/rename-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAE9B;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,QAA6B,CAAC;AAEnE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IACnC;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACvB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,MAAM,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,GAClB,iBAAiB,CASnB;AAED;;;;GAIG;AACH,qBAAa,cAAc;IACvB,QAAQ,8BAAqC;IAC7C,QAAQ,cAAqB;IAC7B,sEAAsE;IACtE,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;gBAExB,aAAa,GAAE,WAAW,CAAC,MAAM,CAAa;IAI1D;;;;;;;;OAQG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,iBAAiB,EAAE,GAAG,SAAS,EAC5C,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,KAAK;IAmCf;;;;;;;OAOG;IACH,GAAG,CACC,IAAI,EAAE,MAAM,EACZ,cAAc,GAAE,MAAM,EAAO;IAC7B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,WAAW,GACxB,YAAY,GAAG,SAAS;IA+B3B,sFAAsF;IACtF,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAMrC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,4EAA4E;IAC5E,MAAM,IAAI,MAAM,EAAE;CAGrB"}

package/assign-names/visit-all.d.ts

@@ -0,0 +1,35 @@
+import { DastElement, DastFunctionMacro, DastMacro, DastNodes } from '../../packages/parser/dist';
+/**
+ * `parents` is the chain of enclosing elements, nearest first, as `visit` from
+ * `@doenet/parser` reports it.
+ *
+ * `attributeOwner` is the element in whose *attribute* the node sits, when it does. A
+ * node among an element's children has none, and descending into an element's children
+ * clears it, so it always names the nearest element the node is written *on* rather than
+ * merely inside.
+ */
+type Visitor = (node: DastNodes, parents: DastElement[], attributeOwner?: DastElement) => void;
+/**
+ * Like `visit` from `@doenet/parser`, but it *also* descends into places that `visit`
+ * ignores:
+ *  - `element.attributes[name].children`
+ *  - `macro.attributes[name].children`
+ *  - `macro.path[i].index[j].value` (including macros nested in indices)
+ *  - `functionMacro.input[i][j]`
+ *
+ * Macro and function-macro nodes are visited **after** their own nested content, so a
+ * visitor that rewrites `macro.path` cannot invalidate an in-progress walk of the macros
+ * that live inside that path's indices.
+ *
+ * Note that, unlike `visit`, there is no way to skip or stop the traversal. This function
+ * is meant for whole-tree rewrites.
+ */
+export declare function visitAll(tree: DastNodes, visitor: Visitor): void;
+/**
+ * Call `visitor` on every macro and function macro anywhere in `tree`, including macros
+ * that appear inside attribute values, inside path indices, and inside function-macro
+ * arguments. Macros are visited innermost-first.
+ */
+export declare function visitAllMacros(tree: DastNodes, visitor: (node: DastMacro | DastFunctionMacro, parents: DastElement[], attributeOwner?: DastElement) => void): void;
+export {};
+//# sourceMappingURL=visit-all.d.ts.map

package/assign-names/visit-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visit-all.d.ts","sourceRoot":"","sources":["../../src/assign-names/visit-all.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,SAAS,EAEZ,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;GAQG;AACH,KAAK,OAAO,GAAG,CACX,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,WAAW,EAAE,EACtB,cAAc,CAAC,EAAE,WAAW,KAC3B,IAAI,CAAC;AAEV;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,QAmGzD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,CACL,IAAI,EAAE,SAAS,GAAG,iBAAiB,EACnC,OAAO,EAAE,WAAW,EAAE,EACtB,cAAc,CAAC,EAAE,WAAW,KAC3B,IAAI,QAeZ"}

package/core-info/core.d.ts

@@ -8,5 +8,6 @@ export declare function createCoreForLookup({ dast }: {
     core: PublicDoenetMLCore;
     rustCore: PublicDoenetMLCoreRust;
     resolvePathToNodeIdx: (name: string, origin?: number) => Promise<number>;
+    dispose: () => Promise<void>;
 }>;
 //# sourceMappingURL=core.d.ts.map

package/core-info/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core-info/core.ts"],"names":[],"mappings":"AAAA,OAAa,EACT,kBAAkB,IAAI,sBAAsB,EAO/C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAyB,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAoCxE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACtC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CACzC,CAAC,sBAAsB,CAAC,CAAC;AAE1B,wBAAsB,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;;;iCA4E9B,MAAM;GAS7C"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core-info/core.ts"],"names":[],"mappings":"AAAA,OAAa,EACT,kBAAkB,IAAI,sBAAsB,EAO/C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAyB,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAoCxE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACtC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CACzC,CAAC,sBAAsB,CAAC,CAAC;AAE1B,wBAAsB,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;;;iCAwH9B,MAAM;;GAyB7C"}

package/core-info/determine-prop-type.d.ts

@@ -12,4 +12,13 @@ export declare function determinePropType(componentType: string, propName: strin
  * The number of indices accessed in the prop. For example `$foo.bar[1][1]` has 2 indices.
  */
 nIndices?: number): string | undefined;
+/**
+ * Whether `componentType` is a `<module>` or something derived from one.
+ *
+ * v0.6 used this to decide the default of `<copy>`'s `link`: with no `link` attribute it
+ * linked everything *except* a copy by cid/uri and a copy of a module (see the `link`
+ * state variable in v0.6's `Copy.js`). v0.7 says linked/unlinked by choosing between the
+ * `extend` and `copy` attributes, so the same question has to be asked here.
+ */
+export declare function isModuleComponentType(componentType: string): boolean;
 //# sourceMappingURL=determine-prop-type.d.ts.map

package/core-info/determine-prop-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"determine-prop-type.d.ts","sourceRoot":"","sources":["../../src/core-info/determine-prop-type.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM;AAChB;;GAEG;AACH,QAAQ,SAAI,sBA8Ff"}
+{"version":3,"file":"determine-prop-type.d.ts","sourceRoot":"","sources":["../../src/core-info/determine-prop-type.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM;AAChB;;GAEG;AACH,QAAQ,SAAI,sBA8Ff;AA0CD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAKpE"}