@driftengine/chemistry 3.61.0

package/dist/substance/composition.js

@@ -0,0 +1,53 @@
+/**
+ * How far a hand-written composition may be from summing to one.
+ *
+ * Generous enough for six fractions typed to three decimals, tight enough that a transposed digit
+ * is a refusal rather than a material that quietly loses half a percent of its mass on every
+ * conservation check.
+ */
+export const SUM_TOLERANCE = 1e-6;
+/**
+ * A composition from species ids and mass fractions.
+ *
+ * Fails fast on anything wrong, per `AGENTS.md`: an unknown id, a fraction that is negative or not
+ * a number, a sum that is not one. Each names the offending value, because "invalid composition" in
+ * a stack trace is a sentence somebody has to reproduce to act on.
+ */
+export function massFractions(registry, entries) {
+    const ids = Object.keys(entries);
+    if (ids.length === 0) {
+        throw new Error('a composition may not be empty');
+    }
+    const pairs = [];
+    let sum = 0;
+    for (const id of ids) {
+        const species = registry.indexOf(id);
+        if (species < 0) {
+            throw new Error(`composition names "${id}", which is not a registered species`);
+        }
+        const fraction = entries[id];
+        if (!Number.isFinite(fraction) || fraction < 0) {
+            throw new Error(`composition gives "${id}" a mass fraction of ${fraction}`);
+        }
+        sum += fraction;
+        pairs.push({ species, fraction });
+    }
+    if (Math.abs(sum - 1) > SUM_TOLERANCE) {
+        throw new Error(`composition sums to ${sum} rather than 1`);
+    }
+    /*
+     * Sorted by species index, not by the order the author typed.
+     *
+     * Adding doubles is not associative, so two spellings of the same material would reduce to
+     * different last bits — and a conservation check is exactly where a last bit becomes a failing
+     * assertion nobody can explain. Sorting here makes the storage canonical, once, at init.
+     */
+    pairs.sort((a, b) => a.species - b.species);
+    const species = new Int32Array(pairs.length);
+    const fraction = new Float64Array(pairs.length);
+    for (let i = 0; i < pairs.length; i++) {
+        species[i] = pairs[i].species;
+        fraction[i] = pairs[i].fraction;
+    }
+    return { species, fraction };
+}

package/dist/substance/registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The substances a world knows about, and the enthalpy curve each one resolves through.
+ *
+ * A curve is expensive to build and constant for the life of a substance, so it is built once here
+ * rather than per parcel. Two hundred oak logs share one curve, which is what makes the whole
+ * approach affordable: the per-parcel cost of a temperature is a binary search over 256 knots and
+ * nothing else.
+ *
+ * A substance is an `i32` index after registration, the convention CH-0 established for a species
+ * and `drift/physics` established for a body.
+ */
+import { type ConductionModel } from '../parcel/conduction.ts';
+import type { SpeciesRegistry } from '../species/registry.ts';
+import type { AppearanceModel, SubstanceThermal } from './substance.ts';
+import type { IgnitionModel } from '../ignition/criteria.ts';
+import type { ReactionRegistry } from '../reaction/registry.ts';
+import { type SubstanceReactions } from '../reaction/solver.ts';
+export declare class SubstanceRegistry {
+    readonly species: SpeciesRegistry;
+    private readonly reactions?;
+    private readonly ids;
+    private readonly byId;
+    private readonly definitions;
+    private readonly conduction;
+    /**
+     * One conduction model per shell count a tier can reduce this substance to, indexed by that count.
+     *
+     * **Built at registration, because `shellGeometry` calls `Math.cbrt`** and `§15` keeps that off the
+     * simulation path entirely — its result is not pinned down by ECMAScript. A level-of-detail tier
+     * that computed geometry when it changed would have put it back there. Four shapes and at most
+     * sixteen counts is nothing to precompute and the alternative is a determinism hole.
+     */
+    private readonly byShellCount;
+    private readonly reactionModels;
+    /** Global species indices this substance's parcels track, ascending. */
+    private readonly speciesSets;
+    /** Global species index to local slot, or -1. One row per substance. */
+    private readonly localSlots;
+    private readonly densities;
+    private readonly porosities;
+    private readonly emissivities;
+    private readonly ignitions;
+    private readonly appearances;
+    constructor(species: SpeciesRegistry, reactions?: ReactionRegistry | undefined);
+    get count(): number;
+    define(substance: SubstanceThermal): number;
+    indexOf(id: string): number;
+    idOf(substance: number): string;
+    conductionOf(substance: number): ConductionModel;
+    /**
+     * The conduction model for a substance resolved to `shells`, which a tier may have reduced it to.
+     *
+     * Precomputed at registration; see `byShellCount` for why it is not derived on demand.
+     */
+    conductionAt(substance: number, shells: number): ConductionModel;
+    densityOf(substance: number): number;
+    /** Void fraction, 0..1. Zero means it exchanges no gas with the air at all. */
+    porosityOf(substance: number): number;
+    /** How readily it radiates and absorbs, 0..1. */
+    emissivityOf(substance: number): number;
+    /** When this material catches, or `null` where nobody said it does. */
+    ignitionOf(substance: number): IgnitionModel | null;
+    /**
+     * What it looks like, or `null` where nobody said.
+     *
+     * `null` rather than a grey default: `present/` writes nothing for a substance with no appearance
+     * rather than inventing one, so a consumer sees their own material unchanged instead of finding
+     * the engine has quietly recoloured it.
+     */
+    appearanceOf(substance: number): AppearanceModel | null;
+    definitionOf(substance: number): SubstanceThermal;
+    /** Global species indices this substance's parcels carry, ascending. */
+    speciesSetOf(substance: number): Int32Array;
+    /** The local slot a global species occupies for this substance, or -1. */
+    localSlotOf(substance: number, species: number): number;
+    reactionsOf(substance: number): SubstanceReactions;
+    /**
+     * The species set and the localised, packed reaction network.
+     *
+     * The set is the composition's species plus everything its reactions touch, so a shell's
+     * composition is a dense run of the few species it can hold rather than a row over all
+     * sixty-eight. Built here, once, because it is a property of the substance.
+     */
+    private buildReactions;
+    private check;
+}

package/dist/substance/registry.js

@@ -0,0 +1,187 @@
+/**
+ * The substances a world knows about, and the enthalpy curve each one resolves through.
+ *
+ * A curve is expensive to build and constant for the life of a substance, so it is built once here
+ * rather than per parcel. Two hundred oak logs share one curve, which is what makes the whole
+ * approach affordable: the per-parcel cost of a temperature is a binary search over 256 knots and
+ * nothing else.
+ *
+ * A substance is an `i32` index after registration, the convention CH-0 established for a species
+ * and `drift/physics` established for a body.
+ */
+import {} from '../parcel/conduction.js';
+import { SHAPE_CYLINDER, shellGeometry } from '../parcel/shells.js';
+import { MAX_SUBSTANCE_SPECIES } from '../reaction/solver.js';
+import { localiseReactions } from '../reaction/localise.js';
+export class SubstanceRegistry {
+    species;
+    reactions;
+    ids = [];
+    byId = new Map();
+    definitions = [];
+    conduction = [];
+    /**
+     * One conduction model per shell count a tier can reduce this substance to, indexed by that count.
+     *
+     * **Built at registration, because `shellGeometry` calls `Math.cbrt`** and `§15` keeps that off the
+     * simulation path entirely — its result is not pinned down by ECMAScript. A level-of-detail tier
+     * that computed geometry when it changed would have put it back there. Four shapes and at most
+     * sixteen counts is nothing to precompute and the alternative is a determinism hole.
+     */
+    byShellCount = [];
+    reactionModels = [];
+    /** Global species indices this substance's parcels track, ascending. */
+    speciesSets = [];
+    /** Global species index to local slot, or -1. One row per substance. */
+    localSlots = [];
+    densities = [];
+    porosities = [];
+    emissivities = [];
+    ignitions = [];
+    appearances = [];
+    constructor(species, reactions) {
+        this.species = species;
+        this.reactions = reactions;
+    }
+    get count() {
+        return this.ids.length;
+    }
+    define(substance) {
+        if (this.byId.has(substance.id)) {
+            throw new Error(`substance "${substance.id}" is already registered`);
+        }
+        if (!(substance.density > 0)) {
+            throw new Error(`substance "${substance.id}" has a density of ${substance.density}`);
+        }
+        /* The shell geometry is a pure function of a shape and a count, so it is resolved here once and
+           multiplied by a parcel's own depth at use — which keeps `Math.cbrt`, whose result ECMAScript
+           does not pin down, off the simulation path entirely. */
+        const geometry = shellGeometry(substance.shape ?? SHAPE_CYLINDER, substance.shells ?? 4);
+        const { set, local, model } = this.buildReactions(substance);
+        const index = this.ids.length;
+        this.speciesSets.push(set);
+        this.localSlots.push(local);
+        this.reactionModels.push(model);
+        const conductivity = substance.conductivity ?? null;
+        this.conduction.push({ geometry, conductivity });
+        const shape = substance.shape ?? SHAPE_CYLINDER;
+        const perCount = [null];
+        for (let count = 1; count <= geometry.count; count++) {
+            perCount.push({ geometry: shellGeometry(shape, count), conductivity });
+        }
+        this.byShellCount.push(perCount);
+        this.ids.push(substance.id);
+        this.byId.set(substance.id, index);
+        this.definitions.push(substance);
+        this.densities.push(substance.density);
+        this.porosities.push(substance.porosity ?? 0);
+        this.emissivities.push(substance.emissivity ?? 0.9);
+        this.ignitions.push(substance.ignition ?? null);
+        this.appearances.push(substance.appearance ?? null);
+        return index;
+    }
+    indexOf(id) {
+        return this.byId.get(id) ?? -1;
+    }
+    idOf(substance) {
+        return this.ids[this.check(substance)];
+    }
+    conductionOf(substance) {
+        return this.conduction[this.check(substance)];
+    }
+    /**
+     * The conduction model for a substance resolved to `shells`, which a tier may have reduced it to.
+     *
+     * Precomputed at registration; see `byShellCount` for why it is not derived on demand.
+     */
+    conductionAt(substance, shells) {
+        const row = this.byShellCount[this.check(substance)];
+        const model = shells >= 1 && shells < row.length ? row[shells] : null;
+        return model ?? this.conduction[substance];
+    }
+    densityOf(substance) {
+        return this.densities[this.check(substance)];
+    }
+    /** Void fraction, 0..1. Zero means it exchanges no gas with the air at all. */
+    porosityOf(substance) {
+        return this.porosities[this.check(substance)];
+    }
+    /** How readily it radiates and absorbs, 0..1. */
+    emissivityOf(substance) {
+        return this.emissivities[this.check(substance)];
+    }
+    /** When this material catches, or `null` where nobody said it does. */
+    ignitionOf(substance) {
+        return this.ignitions[this.check(substance)];
+    }
+    /**
+     * What it looks like, or `null` where nobody said.
+     *
+     * `null` rather than a grey default: `present/` writes nothing for a substance with no appearance
+     * rather than inventing one, so a consumer sees their own material unchanged instead of finding
+     * the engine has quietly recoloured it.
+     */
+    appearanceOf(substance) {
+        return this.appearances[this.check(substance)];
+    }
+    definitionOf(substance) {
+        return this.definitions[this.check(substance)];
+    }
+    /** Global species indices this substance's parcels carry, ascending. */
+    speciesSetOf(substance) {
+        return this.speciesSets[this.check(substance)];
+    }
+    /** The local slot a global species occupies for this substance, or -1. */
+    localSlotOf(substance, species) {
+        const row = this.localSlots[this.check(substance)];
+        return species >= 0 && species < row.length ? row[species] : -1;
+    }
+    reactionsOf(substance) {
+        return this.reactionModels[this.check(substance)];
+    }
+    /**
+     * The species set and the localised, packed reaction network.
+     *
+     * The set is the composition's species plus everything its reactions touch, so a shell's
+     * composition is a dense run of the few species it can hold rather than a row over all
+     * sixty-eight. Built here, once, because it is a property of the substance.
+     */
+    buildReactions(substance) {
+        const ids = substance.reactions ?? [];
+        const present = new Set();
+        for (const s of substance.composition.species)
+            present.add(s);
+        if (this.reactions !== undefined) {
+            for (const id of ids) {
+                const r = this.reactions.indexOf(id);
+                if (r < 0)
+                    throw new Error(`substance "${substance.id}" declares reaction "${id}", which is not registered`);
+                for (const sp of this.reactions.reactantSpecies(r))
+                    present.add(sp);
+                for (const sp of this.reactions.productSpecies(r))
+                    present.add(sp);
+            }
+        }
+        else if (ids.length > 0) {
+            throw new Error(`substance "${substance.id}" declares reactions, and this registry was built with none`);
+        }
+        const set = Int32Array.from([...present].sort((a, b) => a - b));
+        if (set.length > MAX_SUBSTANCE_SPECIES) {
+            throw new Error(`substance "${substance.id}" would track ${set.length} species; the limit is ${MAX_SUBSTANCE_SPECIES}`);
+        }
+        const local = new Int32Array(this.species.count).fill(-1);
+        for (let i = 0; i < set.length; i++)
+            local[set[i]] = i;
+        return {
+            set,
+            local,
+            model: localiseReactions(this.species, this.reactions, ids, set, `substance "${substance.id}"`),
+        };
+    }
+    check(substance) {
+        if (!Number.isInteger(substance) || substance < 0 || substance >= this.ids.length) {
+            throw new Error(`substance ${substance} is outside a registry of ${this.ids.length}`);
+        }
+        return substance;
+    }
+}

package/dist/substance/substance.d.ts

@@ -0,0 +1,94 @@
+import type { SpeciesRegistry } from '../species/registry.ts';
+import { type Composition } from './composition.ts';
+import type { Conductivity } from '../parcel/conduction.ts';
+import type { Shape } from '../parcel/shells.ts';
+import type { IgnitionModel } from '../ignition/criteria.ts';
+export interface SubstanceThermal {
+    readonly id: string;
+    /**
+     * What it is made of **at the bottom of the curve**, as mass fractions summing to one.
+     *
+     * The rule matters and is not obvious: transitions are applied in ascending temperature order, so
+     * a substance is authored as its coldest form. Water is `H2O(s)` with two transitions, not
+     * `H2O(l)` with one in each direction. A transition whose source species is absent when it is
+     * reached is refused, naming both, rather than silently doing nothing.
+     */
+    readonly composition: Composition;
+    /** kg/m³ of the dry matter. */
+    readonly density: number;
+    /**
+     * W/(m·K), rising with temperature. **Optional, and conduction refuses a substance without one**,
+     * naming it — a thermal conductivity nobody stated is a number somebody invented, and it decides
+     * whether a log takes twenty seconds or twenty minutes.
+     */
+    readonly conductivity?: Conductivity;
+    /** How many nested shells of equal mass. Four by default; see `§4` for why not one and why not sixteen. */
+    readonly shells?: number;
+    /** What it is shaped like, which decides how those shells divide. A cylinder by default: a log. */
+    readonly shape?: Shape;
+    /**
+     * Void fraction, 0..1. What decides how freely gas moves between this material and the air.
+     *
+     * A charcoal briquette breathes and a pane of glass does not, and that is most of the difference
+     * between something that smoulders and something that does not. Zero by default, which means a
+     * substance exchanges no gas at all until somebody says how open it is.
+     */
+    readonly porosity?: number;
+    /** How readily it radiates and absorbs, 0..1. Most non-metals sit near 0.9, which is the default. */
+    readonly emissivity?: number;
+    /**
+     * Reactions this material can undergo, by id.
+     *
+     * A substance's parcels track masses for its composition species **plus every species these
+     * reactions touch**, so declaring one is what makes room for its products. Wood that pyrolyses
+     * holds char and steam it did not start with.
+     */
+    readonly reactions?: readonly string[];
+    /**
+     * When this material catches and when it stops.
+     *
+     * Absent means it never catches at all, which is the right default: a substance nobody described
+     * as flammable should not be, and inventing an ignition temperature for glass is worse than
+     * declining to have one.
+     */
+    readonly ignition?: IgnitionModel;
+    /**
+     * What it looks like, and every field is a measurable property of the material rather than a
+     * choice about how to draw it.
+     *
+     * Absent means a consumer supplies their own colours, which is the right default: a substance
+     * nobody described the appearance of should not have one invented for it. `present/` refuses to
+     * write an albedo it was never given rather than writing grey.
+     */
+    readonly appearance?: AppearanceModel;
+}
+/**
+ * `§17`'s three numbers: what a material looks like before it burns, after it burns, and how dirty
+ * its smoke is on the way.
+ *
+ * **Soot yield belongs on the substance and `§8.4` says why**: polystyrene sooting heavily and
+ * methanol burning invisibly are the two ends of a scale, and which end a fuel sits at is a property
+ * of the fuel. It is the one number that decides whether a fire is seen at all in daylight.
+ */
+export interface AppearanceModel {
+    /** Linear RGB before anything happens to it. */
+    readonly albedo: readonly [number, number, number];
+    /** Linear RGB when it is entirely char. Near-black for anything that chars at all. */
+    readonly charAlbedo: readonly [number, number, number];
+    /** kg of soot per kg of volatiles burnt. Wood is about 0.015; polystyrene is 0.16. */
+    readonly sootYield: number;
+}
+/**
+ * A composition with dry-basis moisture folded into it.
+ *
+ * **"12% moisture content" means 12 kg of water per 100 kg of *dry* matter**, so water is
+ * `m / (1 + m)` of the whole and every dry component is scaled by `1 / (1 + m)`. Treating the
+ * figure as a wet-basis fraction is wrong by 1.4 points at 12% and by 33 points for green wood at
+ * 60%, which is exactly the range where it decides whether a log catches fire at all.
+ *
+ * Water the composition already held is added to rather than replaced, because a substance can be
+ * authored wet: a stew is mostly water before anybody adds moisture to it.
+ */
+export declare function wetComposition(registry: SpeciesRegistry, dry: Composition, moisture: number): Composition;
+/** Moles of each element in one kilogram of a composition. Writes into `out`, allocates nothing. */
+export declare function compositionElements(registry: SpeciesRegistry, composition: Composition, out: Float64Array): void;

package/dist/substance/substance.js

@@ -0,0 +1,48 @@
+/**
+ * What a material is, thermally: a composition, a density, and the transitions it passes through.
+ *
+ * CH-1's half of `Substance`. The design's `§5` describes the whole of it — conductivity,
+ * emissivity, porosity, shells, reactions, ignition, appearance — and each field arrives with the
+ * phase that reads it. Declaring them all here with nothing reading them would be the speculative
+ * abstraction `AGENTS.md` §Module rules forbids.
+ */
+import { ELEMENT_COUNT } from '../element/elements.js';
+import { massFractions } from './composition.js';
+/**
+ * A composition with dry-basis moisture folded into it.
+ *
+ * **"12% moisture content" means 12 kg of water per 100 kg of *dry* matter**, so water is
+ * `m / (1 + m)` of the whole and every dry component is scaled by `1 / (1 + m)`. Treating the
+ * figure as a wet-basis fraction is wrong by 1.4 points at 12% and by 33 points for green wood at
+ * 60%, which is exactly the range where it decides whether a log catches fire at all.
+ *
+ * Water the composition already held is added to rather than replaced, because a substance can be
+ * authored wet: a stew is mostly water before anybody adds moisture to it.
+ */
+export function wetComposition(registry, dry, moisture) {
+    if (!Number.isFinite(moisture) || moisture < 0) {
+        throw new Error(`moisture content is ${moisture}, which is not a non-negative number`);
+    }
+    if (moisture === 0)
+        return dry;
+    const scale = 1 / (1 + moisture);
+    const entries = {};
+    for (let i = 0; i < dry.species.length; i++) {
+        entries[registry.idOf(dry.species[i])] = dry.fraction[i] * scale;
+    }
+    const water = 'H2O(l)';
+    entries[water] = (entries[water] ?? 0) + moisture * scale;
+    return massFractions(registry, entries);
+}
+/** Moles of each element in one kilogram of a composition. Writes into `out`, allocates nothing. */
+export function compositionElements(registry, composition, out) {
+    if (out.length !== ELEMENT_COUNT) {
+        throw new Error(`a totals vector is ${ELEMENT_COUNT} wide, not ${out.length}`);
+    }
+    out.fill(0);
+    for (let i = 0; i < composition.species.length; i++) {
+        const species = composition.species[i];
+        const kilograms = composition.fraction[i];
+        registry.elements.addScaledRow(species, kilograms / registry.molarMass(species), out);
+    }
+}

package/dist/testing/drift.d.ts

@@ -0,0 +1,15 @@
+/**
+ * How far two element vectors have drifted apart, for the conservation harness.
+ *
+ * Relative rather than absolute, because the elements in a burning world span many orders of
+ * magnitude at once: a scene may hold a kilomole of nitrogen and a micromole of sulphur, and an
+ * absolute tolerance either passes on a broken sulphur balance or fails on a correct nitrogen one.
+ *
+ * **With one exception that matters.** Where both sides are effectively zero, a relative measure
+ * has nothing to divide by — and an element that appeared from nowhere would then report as no
+ * drift at all, which is the single failure this harness exists to catch. So the denominator has a
+ * floor of one, making the measure absolute in that regime.
+ *
+ * Test-side rather than runtime: nothing in the simulation calls it.
+ */
+export declare function maxElementDrift(a: Float64Array, b: Float64Array): number;

package/dist/testing/drift.js

@@ -0,0 +1,29 @@
+/**
+ * How far two element vectors have drifted apart, for the conservation harness.
+ *
+ * Relative rather than absolute, because the elements in a burning world span many orders of
+ * magnitude at once: a scene may hold a kilomole of nitrogen and a micromole of sulphur, and an
+ * absolute tolerance either passes on a broken sulphur balance or fails on a correct nitrogen one.
+ *
+ * **With one exception that matters.** Where both sides are effectively zero, a relative measure
+ * has nothing to divide by — and an element that appeared from nowhere would then report as no
+ * drift at all, which is the single failure this harness exists to catch. So the denominator has a
+ * floor of one, making the measure absolute in that regime.
+ *
+ * Test-side rather than runtime: nothing in the simulation calls it.
+ */
+export function maxElementDrift(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`element vectors are ${a.length} and ${b.length} wide`);
+    }
+    let worst = 0;
+    for (let i = 0; i < a.length; i++) {
+        const left = a[i];
+        const right = b[i];
+        const scale = Math.max(1, Math.abs(left), Math.abs(right));
+        const drift = Math.abs(left - right) / scale;
+        if (drift > worst)
+            worst = drift;
+    }
+    return worst;
+}

package/dist/transport/contacts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Which parcels are touching, this tick.
+ *
+ * Refilled by the caller each tick rather than held, the same shape `RadiativeSources` takes and
+ * for the same reason: contact is a property of the world's arrangement, which this package does
+ * not know. In practice it is fed from Track B's contact event buffer, which already reports pairs
+ * by feature id — and feeding it is the whole of what a consumer does to make a pan heat a steak.
+ */
+export declare class ContactSet {
+    private a;
+    private b;
+    private area;
+    private used;
+    get count(): number;
+    clear(): void;
+    /** @param area m² of shared surface, which is what sets how fast heat crosses. */
+    add(a: number, b: number, area: number): void;
+    firstOf(contact: number): number;
+    secondOf(contact: number): number;
+    areaOf(contact: number): number;
+    private grow;
+}

package/dist/transport/contacts.js

@@ -0,0 +1,50 @@
+/**
+ * Which parcels are touching, this tick.
+ *
+ * Refilled by the caller each tick rather than held, the same shape `RadiativeSources` takes and
+ * for the same reason: contact is a property of the world's arrangement, which this package does
+ * not know. In practice it is fed from Track B's contact event buffer, which already reports pairs
+ * by feature id — and feeding it is the whole of what a consumer does to make a pan heat a steak.
+ */
+export class ContactSet {
+    a = new Int32Array(32);
+    b = new Int32Array(32);
+    area = new Float64Array(32);
+    used = 0;
+    get count() {
+        return this.used;
+    }
+    clear() {
+        this.used = 0;
+    }
+    /** @param area m² of shared surface, which is what sets how fast heat crosses. */
+    add(a, b, area) {
+        if (this.used === this.a.length)
+            this.grow();
+        const at = this.used++;
+        this.a[at] = a;
+        this.b[at] = b;
+        this.area[at] = area;
+    }
+    firstOf(contact) {
+        return this.a[contact];
+    }
+    secondOf(contact) {
+        return this.b[contact];
+    }
+    areaOf(contact) {
+        return this.area[contact];
+    }
+    grow() {
+        const size = this.a.length * 2;
+        const a = new Int32Array(size);
+        a.set(this.a);
+        this.a = a;
+        const b = new Int32Array(size);
+        b.set(this.b);
+        this.b = b;
+        const area = new Float64Array(size);
+        area.set(this.area);
+        this.area = area;
+    }
+}