@ng-native/fabric 0.9.0 → 0.11.0

package/dist/css.d.ts

@@ -51,6 +51,11 @@ export interface Compound {
     readonly nth?: readonly NthTest[];
     /** `:empty`: no children at all, text included. */
     readonly empty?: true;
+    /**
+     * What a `::ng-deep` is written after: an element of the component the sheet is of, or its
+     * host. A rule with one is for what is under it, in other components' views too.
+     */
+    readonly own?: true;
     /** `:has()`: every one of these must find a match beneath the node. */
     readonly has?: readonly HasTest[];
 }
@@ -65,6 +70,8 @@ export interface NthTest {
     readonly a: number;
     readonly b: number;
     readonly fromEnd?: true;
+    /** Counted among the siblings with the node's own element name: `:nth-of-type()`. */
+    readonly ofType?: true;
 }
 export type Combinator = 'descendant' | 'child' | 'next-sibling' | 'later-sibling';
 export interface StyleRule {
@@ -72,6 +79,8 @@ export interface StyleRule {
     /** Between compounds; length is `compounds.length - 1`. */
     readonly combinators: readonly Combinator[];
     readonly specificity: number;
+    /** Written with `::ng-deep`: for what is under its component, in other components' views too. */
+    readonly deep?: true;
     /**
      * The cascade layer the rule is in, as its place in its sheet's `layers`, or nothing for a rule
      * in no layer, which beats every layered one whatever their specificity.
@@ -162,6 +171,16 @@ export interface TokenValue {
     readonly lineHeight?: {
         readonly __defer: DeferredDeclaration['compute'];
     };
+    /**
+     * Two to four lengths, which a shorthand of sides or corners takes a value each from:
+     * `padding: var(--list-padding)` of `--list-padding: 0.25rem 0.5rem`.
+     */
+    readonly lengths?: readonly (number | string)[];
+    /**
+     * The same where a part is a `var()`, each such part as the alias a token that is one is:
+     * `0 var(--modal-padding) var(--modal-padding)`. Worked out into `lengths` where it is defined.
+     */
+    readonly deferredLengths?: readonly (number | string | TokenValue)[];
     /** A whole shadow list, in the processed shape `boxShadow` takes. */
     readonly shadow?: readonly unknown[];
     /** One filter function, as the one-entry list `filter` takes: a slot of Tailwind's filters. */
@@ -674,6 +693,15 @@ export interface SiblingReach {
  * Where no sheet reaches either way, only the elements at the two ends can match differently.
  */
 export declare function siblingReach(sheet: StyleSheet): SiblingReach;
+/**
+ * A compound whose element's place is read from another element, with the classes the rule asks
+ * of what that element is in: its parent's where `child`, and otherwise of anything above it.
+ */
+export interface PlaceReader {
+    readonly compound: Compound;
+    readonly above?: readonly string[];
+    readonly child?: boolean;
+}
 /**
  * Each compound in a sheet whose element's place among its siblings is read from another
  * element: one with something under it in the rule, `.row:nth-child(odd) .label` and
@@ -687,7 +715,7 @@ export declare function siblingReach(sheet: StyleSheet): SiblingReach;
  * A place read by the element a rule styles, or by the elements before it that the rule steps
  * from (`.a:first-child + .b`), is that element's own: the rules it matches say.
  */
-export declare function placeReadElsewhere(sheet: StyleSheet): readonly Compound[];
+export declare function placeReadElsewhere(sheet: StyleSheet): readonly PlaceReader[];
 /** One rule in a cascade: the sheet it came from, which `:host` needs, and its weight here. */
 interface RuleEntry {
     readonly rule: StyleRule;
@@ -757,6 +785,17 @@ export interface Subjects {
      */
     own?: boolean;
 }
+/**
+ * A box a rule asks `:has()` of that is not the node it styles, `.card:has(.x) .title`, by the
+ * classes the rule asks of that box, with what the rule is for: the nodes under such a box to
+ * match again when what is in it changes.
+ */
+export interface HasAbove {
+    readonly classes: readonly string[];
+    readonly subjects: Subjects;
+}
+/** Each box a sheet's rules ask `:has()` of above the node they style. */
+export declare function hasAbove(sheet: StyleSheet): readonly HasAbove[];
 /** Whether an inline style sets a property children inherit. Allocates nothing: it runs per set. */
 export declare function setsInherited(style: unknown): boolean;
 /**
@@ -878,6 +917,12 @@ export declare class StyleResolver {
     /** The tests of the `class` attribute itself in those sheets, which any class may answer. */
     private readonly classTests;
     private readonly noted;
+    /**
+     * The sheets with a rule written with `::ng-deep`, which is for what is under the component
+     * in the views of the components it holds. None in most apps, and nothing is asked then.
+     */
+    private readonly deepSheets;
+    private readonly deepIndexes;
     /** Read the classes a sheet names, once, as soon as any node is given it. */
     noteSheet(sheet: StyleSheet | null | undefined): void;
     /** The props a selector of some sheet asks about: an id, and each attribute by its name. */
@@ -1009,6 +1054,13 @@ export declare class StyleResolver {
      * it, so it loses to their extra attribute and wins a tie with them.
      */
     private rulesFor;
+    /**
+     * Add the `::ng-deep` rules of each component a node is in whose sheet is not the node's own:
+     * a node is tried against its own component's rules already, those among them.
+     */
+    private reachedFromAbove;
+    /** A sheet's `::ng-deep` rules alone, filed as a component's own are. */
+    private deepIndex;
     /** Weakest first: by layer where any sheet has one, then by weight, then as they were filed. */
     private readonly cascadeOrder;
     /** A component's sheet as the rules of a host or of a creator, which differ only in their place. */
@@ -1049,6 +1101,8 @@ export declare class StyleResolver {
      * edge the inline style sets takes the other form of it out, as a later rule would.
      */
     overOtherForms(inline: Readonly<Record<string, unknown>>, style: Record<string, unknown>): void;
+    /** Whether a settled style is of an element read right to left: by its own, or the app's. */
+    readsRightToLeft(style: Readonly<Record<string, unknown>>): boolean;
     /**
      * The direction an element is laid out in: the last `direction` its own rules give it, the one
      * it inherits, or the app's. A logical corner is a different physical one in each.

package/dist/css.js

@@ -259,6 +259,16 @@ function matchesValue(value, operator, expected) {
             return value === expected || value.startsWith(`${expected}-`);
     }
 }
+/**
+ * Whether a node is one a compound written before `::ng-deep` may be: an element of the view of
+ * the component the sheet is of. Its host is one only where the compound says `:host`, which is
+ * asked of it already: a class a parent gives the host is no anchor.
+ */
+function ownedBy(node, compound, sheet) {
+    if (compound.host !== undefined || compound.hostContext !== undefined)
+        return true;
+    return node.sheet === sheet;
+}
 /*
  * Exempt from the complexity limit deliberately. This is a flat conjunction of independent
  * guards, not nested logic: cyclomatic complexity scores the two the same, and they are not the
@@ -280,6 +290,8 @@ function matchesCompound(node, compound, sheet) {
     }
     if (compound.type !== undefined && compound.type !== node.name)
         return false;
+    if (compound.own !== undefined && !ownedBy(node, compound, sheet))
+        return false;
     if (compound.id !== undefined && node.props['nativeID'] !== compound.id)
         return false;
     for (const className of compound.classes) {
@@ -433,6 +445,82 @@ function matchAny(first, next, rule, index, compound, sheet) {
     }
     return false;
 }
+const BIT_OF = new Map();
+/** Past this many names the bits are worked out again: ids made per row would be kept for ever. */
+const BITS_KEPT = 4096;
+/** The bit a class, a name or an id has among the sixty-four. */
+function bitOf(kind, name) {
+    const key = kind + name;
+    let bit = BIT_OF.get(key);
+    if (bit === undefined) {
+        let hash = 0;
+        for (let at = 0; at < key.length; at++)
+            hash = (Math.imul(hash, 31) + key.charCodeAt(at)) | 0;
+        bit = (hash ^ (hash >>> 16)) & 63;
+        // A bit is its name's hash, so one forgotten is the same when it is asked for again.
+        if (BIT_OF.size >= BITS_KEPT)
+            BIT_OF.clear();
+        BIT_OF.set(key, bit);
+    }
+    return bit;
+}
+const NAMED_ABOVE = new WeakMap();
+/**
+ * The classes, names and ids a rule names of the node's ancestors: of each part joined to what
+ * is on its right by a descendant or a child combinator. One joined by a sibling combinator is
+ * no ancestor of the node, though the parts to its left that are ancestors of it are ancestors
+ * of the node as well. Null where it names none, a rule of one part among them.
+ */
+function namedAbove(rule) {
+    let named = NAMED_ABOVE.get(rule);
+    if (named !== undefined)
+        return named;
+    let [low, high] = [0, 0];
+    const add = (bit) => {
+        if (bit < 32)
+            low |= 1 << bit;
+        else
+            high |= 1 << (bit - 32);
+    };
+    for (let at = 0; at < rule.compounds.length - 1; at++) {
+        const joined = rule.combinators[at];
+        if (joined === 'next-sibling' || joined === 'later-sibling')
+            continue;
+        const compound = rule.compounds[at];
+        for (const className of compound.classes)
+            add(bitOf('.', className));
+        if (compound.type !== undefined)
+            add(bitOf('<', compound.type));
+        if (compound.id !== undefined)
+            add(bitOf('#', compound.id));
+    }
+    named = low === 0 && high === 0 ? null : [low, high];
+    NAMED_ABOVE.set(rule, named);
+    return named;
+}
+/** The classes, names and ids of a node's ancestors, as bits. */
+function bitsAbove(node) {
+    let [low, high] = [0, 0];
+    const add = (bit) => {
+        if (bit < 32)
+            low |= 1 << bit;
+        else
+            high |= 1 << (bit - 32);
+    };
+    for (let up = node.parent; up; up = up.parent) {
+        if (up.classes)
+            for (const className of up.classes)
+                add(bitOf('.', className));
+        if (up.name !== undefined)
+            add(bitOf('<', up.name));
+        const id = up.props?.['nativeID'];
+        if (typeof id === 'string')
+            add(bitOf('#', id));
+    }
+    return [low, high];
+}
+/** Whether what is above a node lacks something a rule names there. */
+const lacks = (above, named) => (named[0] & ~above[0]) !== 0 || (named[1] & ~above[1]) !== 0;
 const TAKES_PARENTS = new WeakMap();
 /** Whether a rule has an `inherit` in it, which is settled from the parent's own style. */
 function takesParents(rule) {
@@ -496,8 +584,9 @@ function stepsAlong(combinators) {
  * matched again by other means, and which way it reaches is not worked out.
  */
 function countSiblings(compound, reach, withinHas) {
-    // Which is first and which is last is the ends, and no count.
-    const counts = (compound.nth ?? []).filter((test) => test.a !== 0 || test.b !== 1);
+    // Which is first and which is last is the ends, and no count. Not of one name: the first of
+    // its name is wherever the others of it are not.
+    const counts = (compound.nth ?? []).filter((test) => test.a !== 0 || test.b !== 1 || test.ofType);
     if (counts.some((test) => withinHas || !test.fromEnd))
         reach.after = Infinity;
     if (counts.some((test) => withinHas || test.fromEnd))
@@ -537,10 +626,13 @@ export function placeReadElsewhere(sheet) {
                 if (joined === 'next-sibling' || joined === 'later-sibling')
                     return;
                 const run = rule.compounds.slice(start, at + 1);
+                // What the run is in: the compound before it, which every element of it is under.
+                const list = rule.compounds[start - 1];
+                const child = rule.combinators[start - 1] === 'child';
                 start = at + 1;
                 const above = at < rule.compounds.length - 1;
                 if (above && (run.length > 1 || run.some(readsPlace)))
-                    elsewhere.push(compound);
+                    elsewhere.push({ compound, above: list?.classes, child });
             });
         }
         known = elsewhere;
@@ -567,7 +659,7 @@ function placeReadAbove(compound, elsewhere) {
     ];
     for (const inner of above)
         if (readsPlace(inner))
-            elsewhere.push(inner);
+            elsewhere.push({ compound: inner });
     for (const inner of nestedCompounds(compound))
         placeReadAbove(inner, elsewhere);
 }
@@ -601,10 +693,10 @@ function matchesNth(node, test) {
     const siblings = node.parent?.children;
     if (!siblings)
         return false;
-    if (test.a === 0 && test.b === 1) {
+    if (test.a === 0 && test.b === 1 && !test.ofType) {
         return (test.fromEnd ? lastElement(siblings) : firstElement(siblings)) === node;
     }
-    const from = countPosition(node, siblings, test.fromEnd === true);
+    const from = countPosition(node, siblings, test.fromEnd === true, test.ofType === true);
     if (from === 0)
         return false;
     // `an + b` for some whole number of steps, which is what CSS counts from.
@@ -822,11 +914,11 @@ function byImportance(matched, places) {
     }));
     return [...plain, ...important];
 }
-function countPosition(node, siblings, fromEnd) {
+function countPosition(node, siblings, fromEnd, ofType) {
     let position = 0;
     let seen = 0;
     for (const sibling of siblings) {
-        if (!isElement(sibling))
+        if (!isElement(sibling) || (ofType && sibling.name !== node.name))
             continue;
         seen++;
         if (sibling === node)
@@ -1128,6 +1220,42 @@ function subjectsOf(sheet) {
     subjects.set(sheet, (found = all));
     return found;
 }
+const HAS_ABOVE = new WeakMap();
+/** Whether a compound, or one it asks of the same node, uses `:has()`. */
+const asksBeneath = (compound) => compound.has !== undefined ||
+    [...(compound.not ?? []), ...(compound.is ?? []).flat()].some(asksBeneath);
+/**
+ * The boxes above the styled node that a compound asks `:has()` of: the compound's own node,
+ * where that is not the styled one, and each box it is asked to be inside,
+ * `.body:is(.card:has(.x) *) .title`.
+ */
+function* boxesAsked(compound, styled) {
+    if (!styled && asksBeneath(compound))
+        yield compound;
+    for (const key of ['ancestors', 'parents', 'hostContext']) {
+        for (const outer of compound[key] ?? [])
+            yield* boxesAsked(outer, false);
+    }
+}
+/** Each box a sheet's rules ask `:has()` of above the node they style. */
+export function hasAbove(sheet) {
+    let known = HAS_ABOVE.get(sheet);
+    if (known === undefined) {
+        const found = [];
+        for (const rule of sheet.rules) {
+            const last = rule.compounds.length - 1;
+            for (const [at, compound] of rule.compounds.entries()) {
+                for (const box of boxesAsked(compound, at === last)) {
+                    const subjects = noSubjects();
+                    noteSubject(subjects, rule);
+                    found.push({ classes: box.classes, subjects });
+                }
+            }
+        }
+        HAS_ABOVE.set(sheet, (known = found));
+    }
+    return known;
+}
 /** Note in `into` what a rule is for. */
 function noteSubject(into, rule) {
     const subject = rule.compounds.at(-1);
@@ -1245,10 +1373,10 @@ function classPlaces(rule) {
         }
         const joined = rule.combinators[index];
         under &&= joined === 'child' || joined === 'descendant';
-        const { classes, ...rest } = compound;
-        collectClasses(rest, elsewhere, []);
-        for (const name of classes)
-            (under ? inside : elsewhere).add(name);
+        // A box the element is under, by its classes and by those it is asked to have or not to,
+        // `.box:not(.busy) .row`: each is asked of that box, as its own are.
+        const over = under ? inside : elsewhere;
+        placeClasses(compound, over, over, elsewhere);
     }
     for (const name of elsewhere) {
         own.delete(name);
@@ -1627,11 +1755,19 @@ export class StyleResolver {
     /** The tests of the `class` attribute itself in those sheets, which any class may answer. */
     classTests = [];
     noted = new WeakSet();
+    /**
+     * The sheets with a rule written with `::ng-deep`, which is for what is under the component
+     * in the views of the components it holds. None in most apps, and nothing is asked then.
+     */
+    deepSheets = new Set();
+    deepIndexes = new WeakMap();
     /** Read the classes a sheet names, once, as soon as any node is given it. */
     noteSheet(sheet) {
         if (!sheet || this.noted.has(sheet))
             return;
         this.noted.add(sheet);
+        if (sheet.rules.some((rule) => rule.deep))
+            this.deepSheets.add(sheet);
         const { classes, reads, named } = classReach(sheet);
         for (const [name, how] of classes)
             this.noteReach(name, how);
@@ -1935,6 +2071,7 @@ export class StyleResolver {
     hasNoRules(node) {
         return (node.sheet === null &&
             node.hostSheet === null &&
+            this.deepSheets.size === 0 &&
             this.globalSheet === null &&
             this.addedSheets.length === 0 &&
             !node.customProperties &&
@@ -2015,9 +2152,33 @@ export class StyleResolver {
             indexes.push(this.ownIndex(node.hostSheet, HOSTS));
         if (node.sheet)
             indexes.push(this.ownIndex(node.sheet, CREATED));
+        if (this.deepSheets.size)
+            this.reachedFromAbove(node, indexes);
         indexes.push(this.sharedIndex());
         return candidateRules(node, indexes, this.cascadeOrder);
     }
+    /**
+     * Add the `::ng-deep` rules of each component a node is in whose sheet is not the node's own:
+     * a node is tried against its own component's rules already, those among them.
+     */
+    reachedFromAbove(node, indexes) {
+        for (let up = node.parent; up; up = up.parent) {
+            const sheet = up.hostSheet;
+            if (!sheet || sheet === node.sheet || sheet === node.hostSheet)
+                continue;
+            if (this.deepSheets.has(sheet))
+                indexes.push(this.deepIndex(sheet));
+        }
+    }
+    /** A sheet's `::ng-deep` rules alone, filed as a component's own are. */
+    deepIndex(sheet) {
+        let index = this.deepIndexes.get(sheet);
+        if (!index) {
+            const deep = this.entries(sheet, COMPONENT_SPECIFICITY_BUMP).filter(({ rule }) => rule.deep);
+            this.deepIndexes.set(sheet, (index = indexRules(deep, undefined, HOSTS * SHEET_ROOM)));
+        }
+        return index;
+    }
     /** Weakest first: by layer where any sheet has one, then by weight, then as they were filed. */
     cascadeOrder = (a, b) => {
         const layers = this.layered
@@ -2157,8 +2318,15 @@ export class StyleResolver {
     /** The rules that apply to a node, weakest first. */
     matched(node, entries) {
         const out = [];
+        // What the node's ancestors are, gathered for the first rule that names one.
+        let above;
         for (const { rule, sheet } of entries) {
-            if (this.conditionHolds(rule) && matches(node, rule, sheet))
+            if (!this.conditionHolds(rule))
+                continue;
+            const named = namedAbove(rule);
+            if (named && lacks((above ??= bitsAbove(node)), named))
+                continue;
+            if (matches(node, rule, sheet))
                 out.push(rule);
         }
         return out;
@@ -2208,13 +2376,17 @@ export class StyleResolver {
         for (const [at, key] of written.entries()) {
             if (!(key in TWIN.ltr))
                 continue;
-            twin ??= TWIN[(style['direction'] ?? this.conditions.direction) === 'rtl' ? 'rtl' : 'ltr'];
+            twin ??= TWIN[this.readsRightToLeft(style) ? 'rtl' : 'ltr'];
             const other = twin[key];
             // Where the inline style sets both, the one it set later stands.
             if (written.indexOf(other) < at)
                 delete style[other];
         }
     }
+    /** Whether a settled style is of an element read right to left: by its own, or the app's. */
+    readsRightToLeft(style) {
+        return (style['direction'] ?? this.conditions.direction) === 'rtl';
+    }
     /**
      * The direction an element is laid out in: the last `direction` its own rules give it, the one
      * it inherits, or the app's. A logical corner is a different physical one in each.
@@ -2682,6 +2854,9 @@ function substitutable(token, tokens) {
         return hslSubstitutable(token.hsl, tokens);
     if (token.deferredColour)
         return colourSubstitutable(token.deferredColour, tokens);
+    if (token.deferredLengths) {
+        return token.deferredLengths.every((part) => typeof part !== 'object' || substitutedIn(part, tokens) !== undefined);
+    }
     // Each marker is one reading of the same text, and a fallback one cannot read is dropped from it.
     return token.deferredCalc.some((marker) => calcSubstitutable(marker.expression, tokens));
 }
@@ -2760,7 +2935,7 @@ function inCycles(names, waitingOn) {
 }
 /** Whether a token is made of others, and so worked out where it is defined. */
 function isDerived(token) {
-    return Boolean(token?.hsl || token?.deferredColour || token?.deferredCalc);
+    return Boolean(token?.hsl || token?.deferredColour || token?.deferredCalc || token?.deferredLengths);
 }
 /** A token made of others, worked out from the tokens in scope. */
 function derived(token, tokens) {
@@ -2768,8 +2943,23 @@ function derived(token, tokens) {
         return colourToken(resolveHsl(token.hsl, tokens));
     if (token.deferredColour)
         return colourToken(resolveColour(token.deferredColour, tokens));
+    if (token.deferredLengths)
+        return lengthsToken(token, tokens);
     return calcToken(token.deferredCalc, tokens);
 }
+/**
+ * A token of several lengths with each part that is a `var()` followed. Where a part comes to
+ * no length the token is what else it reads as, a shadow whose colour is a token being several
+ * lengths and a `var()` too, or nothing where it reads as nothing else.
+ */
+function lengthsToken(token, tokens) {
+    const { deferredLengths, ...rest } = token;
+    const lengths = deferredLengths.map((part) => typeof part === 'object' ? substitutedIn(part, tokens)?.length : part);
+    if (lengths.every((length) => length !== undefined)) {
+        return { ...rest, lengths: lengths };
+    }
+    return Object.keys(rest).length ? rest : undefined;
+}
 /**
  * Each alias settled to what it names. `follow` writes back every one that resolves; one in a
  * cycle is removed only once all are followed, as removed any sooner, the next one round the
@@ -2943,7 +3133,7 @@ function referenced(declaration, tokens) {
     // property unset rather than trying the next, or the fallback.
     const names = [declaration.reference, ...(declaration.alternatives ?? [])];
     const token = firstSet(names, tokens);
-    let value = token ? tokenForm(token, declaration.kind) : fallbackOf(declaration, tokens);
+    let value = token ? formFor(token, declaration) : fallbackOf(declaration, tokens);
     // `calc(var(--n) * 1px)`: the arithmetic gives a unitless token its unit, which is the usual
     // way to turn a count into a length. So it reads the bare number, and a length is no such thing.
     if (token && declaration.adjust?.number && declaration.kind === 'length') {
@@ -2991,9 +3181,52 @@ function tokenForm(token, kind) {
     const value = formOf(token, kind);
     return value === undefined && kind === 'color' && isCurrentColour(token) ? CURRENT_COLOUR : value;
 }
+/** A corner's place among four as CSS writes them, before a side's: `borderTopLeftRadius`. */
+const PLACES = [
+    [/TopLeft|TopStart|StartStart/, 0],
+    [/TopRight|TopEnd|StartEnd/, 1],
+    [/BottomRight|BottomEnd|EndEnd/, 2],
+    [/BottomLeft|BottomStart|EndStart/, 3],
+    [/Top/, 0],
+    [/Right|End/, 1],
+    [/Bottom/, 2],
+    [/Left|Start/, 3],
+];
+/** Where a side or a corner comes in a shorthand of four, whatever order its props are kept in. */
+const placeOf = (prop) => PLACES.find(([named]) => named.test(prop))?.[1] ?? 0;
+/** The lengths of a token that holds several, for the props of a shorthand to take one each. */
+class EachSide {
+    lengths;
+    constructor(lengths) {
+        this.lengths = lengths;
+    }
+    /**
+     * The length for one of a shorthand's four props, as CSS gives them: two are a pair repeated,
+     * and of three the left takes the right's. Nothing for a property that is not such a
+     * shorthand: a token of several lengths is no value for it, and it is unset.
+     */
+    at(props, prop) {
+        if (props.length !== 4)
+            return undefined;
+        const index = placeOf(prop);
+        return this.lengths[index] ?? this.lengths[index - 2] ?? this.lengths[0];
+    }
+}
+/**
+ * A set token's value in the form a declaration wants, or its several lengths where it wants a
+ * length and the token has no one: for a shorthand that takes one a side, see `writeSettled`.
+ * Not with arithmetic on it, which is of one length.
+ */
+function formFor(token, declaration) {
+    const value = tokenForm(token, declaration.kind);
+    if (value !== undefined || !token.lengths || declaration.kind !== 'length')
+        return value;
+    return declaration.adjust ? undefined : new EachSide(token.lengths);
+}
 /** What a deferred declaration settled to, written to one of its props. */
 function writeSettled(own, prop, declaration, settled, layers) {
-    const value = settled ?? declaration.unset;
+    const one = settled instanceof EachSide ? settled.at(declaration.props, prop) : settled;
+    const value = one ?? declaration.unset;
     if (declaration.layers)
         writeLayer(own, prop, value, layers);
     else