@rpgm-tools/neo-angband-core 0.10.0

package/dist/bitflag.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Low-level bit vector manipulation, ported from reference/src/z-bitflag.c/h
+ * (Angband 4.2.6).
+ *
+ * A flag set is a Uint8Array of bytes ("bitflag" is uint8_t upstream). Flags
+ * are 1-indexed: FLAG_START is 1 and flag 0 is the upstream FLAG_END
+ * sentinel, which never tests as set. The byte size of a set able to hold n
+ * flags is flagSize(n), mirroring the upstream FLAG_SIZE macro.
+ *
+ * Sentinel mapping: upstream flag_next() returns FLAG_END (0) when no more
+ * flags are set. This port returns NO_FLAG (-1) instead so that the "no
+ * flag" pseudo-value 0 is never conflated with an iteration result; loops
+ * must compare against NO_FLAG. Upstream's variadic functions (flags_test
+ * and friends) terminate their argument list with FLAG_END; this port uses
+ * rest parameters instead, so no terminator is passed.
+ *
+ * Intentional divergences, each noted on the function it affects:
+ * - The C functions take an explicit byte size next to the array; here the
+ *   Uint8Array length is the size. Binary operations require equal lengths.
+ * - flag_on/flag_off with flag 0 is undefined behavior upstream (1 << -1);
+ *   this port throws a RangeError instead.
+ * - flagCompUnion/flagCompInter/flagCompDiff: upstream 4.2.6 declares no
+ *   such functions; the only trace is the never-expanded macro
+ *   rf_comp_union in src/monster.h line 114. They are defined here as the
+ *   natural complement reading: apply union/inter/diff with the bitwise
+ *   complement of the second operand.
+ */
+/** Bits per bitflag array element (sizeof(uint8_t) * 8). */
+export declare const FLAG_WIDTH = 8;
+/** Enum flag value of the first valid flag in a set. */
+export declare const FLAG_START = 1;
+/**
+ * The upstream sentinel meaning "no flag" (FLAG_START - 1). flag 0 is never
+ * set. Note that flagNext returns NO_FLAG, not FLAG_END; see module docs.
+ */
+export declare const FLAG_END: number;
+/** Iteration sentinel returned by flagNext when no further flag is set. */
+export declare const NO_FLAG = -1;
+/** The array size (in bytes) necessary to hold n flags (FLAG_SIZE). */
+export declare function flagSize(n: number): number;
+/** The highest flag value plus one in an array of size bytes (FLAG_MAX). */
+export declare function flagMax(size: number): number;
+/**
+ * flag_has: tests if a flag is on in a bitflag set. Flag 0 (FLAG_END) is
+ * always false, as upstream.
+ */
+export declare function flagHas(flags: Uint8Array, flag: number): boolean;
+/**
+ * flag_next: returns the next on flag, starting from (and including) flag.
+ * Returns NO_FLAG when the end of the set is reached (upstream returns
+ * FLAG_END). Iteration starts at the beginning of the set when flag is
+ * FLAG_END or lower; upstream relies on x86 shift masking for flag 0, which
+ * skips it, so starting at FLAG_START is behavior-identical.
+ */
+export declare function flagNext(flags: Uint8Array, flag: number): number;
+/** flag_count: counts the flags which are on in a bitflag set. */
+export declare function flagCount(flags: Uint8Array): number;
+/** flag_is_empty: true when no flags are set. */
+export declare function flagIsEmpty(flags: Uint8Array): boolean;
+/**
+ * flag_is_full: true when all flags are set. As upstream, this checks whole
+ * bytes (0xff), so trailing padding bits beyond the last real flag count.
+ */
+export declare function flagIsFull(flags: Uint8Array): boolean;
+/** flag_is_inter: true when any flag is set in both sets. */
+export declare function flagIsInter(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_is_subset: true when every set flag in flags2 is also set in flags1
+ * (i.e. flags2 is a subset of flags1). Argument order follows upstream.
+ */
+export declare function flagIsSubset(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/** flag_is_equal: true when both sets have identical flags. */
+export declare function flagIsEqual(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_on: sets one flag. Returns true when a change was made, false when
+ * the flag was already set.
+ */
+export declare function flagOn(flags: Uint8Array, flag: number): boolean;
+/**
+ * flag_off: clears one flag. Returns true when a change was made, false
+ * when the flag was already clear.
+ */
+export declare function flagOff(flags: Uint8Array, flag: number): boolean;
+/** flag_wipe: clears all flags. */
+export declare function flagWipe(flags: Uint8Array): void;
+/** flag_setall: sets all flags (whole bytes, as upstream memset 255). */
+export declare function flagSetall(flags: Uint8Array): void;
+/** flag_negate: toggles all flags. */
+export declare function flagNegate(flags: Uint8Array): void;
+/** flag_copy: copies flags2 into flags1. */
+export declare function flagCopy(flags1: Uint8Array, flags2: Uint8Array): void;
+/**
+ * flag_union: flags1 |= flags2. Returns true when changes were made (some
+ * flag of flags2 was not already set in flags1).
+ */
+export declare function flagUnion(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_inter: flags1 &= flags2. Upstream quirk kept faithfully: the return
+ * value reports whether flags1 and flags2 DIFFERED (per byte), not whether
+ * flags1 was actually modified. E.g. flags1 = 0x01, flags2 = 0x03 returns
+ * true even though flags1 is unchanged.
+ */
+export declare function flagInter(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_diff: flags1 &= ~flags2 (clears every flag set in flags2). Returns
+ * true when changes were made (the sets intersected).
+ */
+export declare function flagDiff(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_comp_union: flags1 |= ~flags2 (union with the complement of flags2).
+ * Not defined upstream (see module docs); returns true when flags1 changed.
+ */
+export declare function flagCompUnion(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_comp_inter: flags1 &= ~flags2 (intersection with the complement of
+ * flags2, i.e. the same mutation as flagDiff). Not defined upstream; returns
+ * true when flags1 changed.
+ */
+export declare function flagCompInter(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flag_comp_diff: flags1 &= ~(~flags2), i.e. flags1 &= flags2 (difference
+ * with the complement of flags2, the same mutation as flagInter). Not
+ * defined upstream; returns true when flags1 changed (NOT the flagInter
+ * inequality quirk).
+ */
+export declare function flagCompDiff(flags1: Uint8Array, flags2: Uint8Array): boolean;
+/**
+ * flags_test: true if any of the given flags are set. Upstream is variadic
+ * with a FLAG_END terminator; this port takes rest parameters.
+ */
+export declare function flagsTest(flags: Uint8Array, ...check: number[]): boolean;
+/** flags_test_all: true if all of the given flags are set. */
+export declare function flagsTestAll(flags: Uint8Array, ...check: number[]): boolean;
+/**
+ * flags_clear: clears the given flags. Returns true when changes were made.
+ */
+export declare function flagsClear(flags: Uint8Array, ...clear: number[]): boolean;
+/** flags_set: sets the given flags. Returns true when changes were made. */
+export declare function flagsSet(flags: Uint8Array, ...set: number[]): boolean;
+/** flags_init: wipes the set, then sets the given flags. */
+export declare function flagsInit(flags: Uint8Array, ...set: number[]): void;
+/**
+ * flags_mask: clears the flags NOT given (intersects with a mask built from
+ * the given flags). Return value keeps the upstream flag_inter inequality
+ * quirk, because upstream implements this via flag_inter.
+ */
+export declare function flagsMask(flags: Uint8Array, ...mask: number[]): boolean;
+/**
+ * An object wrapper around a Uint8Array flag set with the upstream API as
+ * methods. Sizes are byte sizes, exactly like the upstream `size`
+ * parameters; use FlagSet.forFlags(maxFlag) to size a set by its highest
+ * flag value (the equivalent of bitflag name[FLAG_SIZE(MAX)]).
+ */
+export declare class FlagSet {
+    readonly bits: Uint8Array;
+    constructor(size: number | Uint8Array);
+    /** Size a set to hold flags FLAG_START..maxFlag - 1 (FLAG_SIZE(max)). */
+    static forFlags(maxFlag: number): FlagSet;
+    /** The byte size of the set (the upstream `size` parameter). */
+    get size(): number;
+    has(flag: number): boolean;
+    /** Next on flag at or after `flag`; NO_FLAG when exhausted. */
+    next(flag: number): number;
+    count(): number;
+    isEmpty(): boolean;
+    isFull(): boolean;
+    /** True when any flag is set in both this set and `other`. */
+    isInter(other: FlagSet): boolean;
+    /**
+     * True when `other` is a subset of this set (every flag set in `other`
+     * is also set in this). Mirrors upstream flag_is_subset(this, other).
+     */
+    isSubset(other: FlagSet): boolean;
+    isEqual(other: FlagSet): boolean;
+    on(flag: number): boolean;
+    off(flag: number): boolean;
+    wipe(): void;
+    setall(): void;
+    negate(): void;
+    /** Copies `other` into this set (upstream flag_copy(this, other)). */
+    copy(other: FlagSet): void;
+    /** A new FlagSet with the same contents. */
+    clone(): FlagSet;
+    union(other: FlagSet): boolean;
+    inter(other: FlagSet): boolean;
+    diff(other: FlagSet): boolean;
+    compUnion(other: FlagSet): boolean;
+    compInter(other: FlagSet): boolean;
+    compDiff(other: FlagSet): boolean;
+    test(...check: number[]): boolean;
+    testAll(...check: number[]): boolean;
+    clear(...clear: number[]): boolean;
+    set(...set: number[]): boolean;
+    init(...set: number[]): void;
+    mask(...mask: number[]): boolean;
+    /** Iterate the set flags in ascending order. */
+    [Symbol.iterator](): IterableIterator<number>;
+}
+//# sourceMappingURL=bitflag.d.ts.map

package/dist/bitflag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitflag.d.ts","sourceRoot":"","sources":["../src/bitflag.ts"],"names":[],"mappings":"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"}

package/dist/bitflag.js

@@ -0,0 +1,478 @@
+/**
+ * Low-level bit vector manipulation, ported from reference/src/z-bitflag.c/h
+ * (Angband 4.2.6).
+ *
+ * A flag set is a Uint8Array of bytes ("bitflag" is uint8_t upstream). Flags
+ * are 1-indexed: FLAG_START is 1 and flag 0 is the upstream FLAG_END
+ * sentinel, which never tests as set. The byte size of a set able to hold n
+ * flags is flagSize(n), mirroring the upstream FLAG_SIZE macro.
+ *
+ * Sentinel mapping: upstream flag_next() returns FLAG_END (0) when no more
+ * flags are set. This port returns NO_FLAG (-1) instead so that the "no
+ * flag" pseudo-value 0 is never conflated with an iteration result; loops
+ * must compare against NO_FLAG. Upstream's variadic functions (flags_test
+ * and friends) terminate their argument list with FLAG_END; this port uses
+ * rest parameters instead, so no terminator is passed.
+ *
+ * Intentional divergences, each noted on the function it affects:
+ * - The C functions take an explicit byte size next to the array; here the
+ *   Uint8Array length is the size. Binary operations require equal lengths.
+ * - flag_on/flag_off with flag 0 is undefined behavior upstream (1 << -1);
+ *   this port throws a RangeError instead.
+ * - flagCompUnion/flagCompInter/flagCompDiff: upstream 4.2.6 declares no
+ *   such functions; the only trace is the never-expanded macro
+ *   rf_comp_union in src/monster.h line 114. They are defined here as the
+ *   natural complement reading: apply union/inter/diff with the bitwise
+ *   complement of the second operand.
+ */
+/** Bits per bitflag array element (sizeof(uint8_t) * 8). */
+export const FLAG_WIDTH = 8;
+/** Enum flag value of the first valid flag in a set. */
+export const FLAG_START = 1;
+/**
+ * The upstream sentinel meaning "no flag" (FLAG_START - 1). flag 0 is never
+ * set. Note that flagNext returns NO_FLAG, not FLAG_END; see module docs.
+ */
+export const FLAG_END = FLAG_START - 1;
+/** Iteration sentinel returned by flagNext when no further flag is set. */
+export const NO_FLAG = -1;
+/** The array size (in bytes) necessary to hold n flags (FLAG_SIZE). */
+export function flagSize(n) {
+    return Math.trunc((n + FLAG_WIDTH - 1) / FLAG_WIDTH);
+}
+/** The highest flag value plus one in an array of size bytes (FLAG_MAX). */
+export function flagMax(size) {
+    return size * FLAG_WIDTH + FLAG_START;
+}
+/** Convert a flag value to its array index (FLAG_OFFSET). */
+function flagOffset(flag) {
+    return Math.trunc((flag - FLAG_START) / FLAG_WIDTH);
+}
+/** Convert a flag value to its binary bit value (FLAG_BINARY). */
+function flagBinary(flag) {
+    return 1 << ((flag - FLAG_START) % FLAG_WIDTH);
+}
+function assertValidFlag(flags, flag, fn) {
+    if (flag < FLAG_START) {
+        throw new RangeError(`${fn}: flag ${flag} is below FLAG_START`);
+    }
+    if (flagOffset(flag) >= flags.length) {
+        throw new RangeError(`${fn}: flag ${flag} does not fit in ${flags.length} byte(s)`);
+    }
+}
+function assertSameSize(a, b, fn) {
+    if (a.length !== b.length) {
+        throw new RangeError(`${fn}: flag set sizes differ (${a.length} vs ${b.length})`);
+    }
+}
+/**
+ * flag_has: tests if a flag is on in a bitflag set. Flag 0 (FLAG_END) is
+ * always false, as upstream.
+ */
+export function flagHas(flags, flag) {
+    if (flag === FLAG_END)
+        return false;
+    assertValidFlag(flags, flag, "flagHas");
+    return (flags[flagOffset(flag)] & flagBinary(flag)) !== 0;
+}
+/**
+ * flag_next: returns the next on flag, starting from (and including) flag.
+ * Returns NO_FLAG when the end of the set is reached (upstream returns
+ * FLAG_END). Iteration starts at the beginning of the set when flag is
+ * FLAG_END or lower; upstream relies on x86 shift masking for flag 0, which
+ * skips it, so starting at FLAG_START is behavior-identical.
+ */
+export function flagNext(flags, flag) {
+    const maxFlags = flagMax(flags.length);
+    for (let f = Math.max(flag, FLAG_START); f < maxFlags; f++) {
+        if ((flags[flagOffset(f)] & flagBinary(f)) !== 0)
+            return f;
+    }
+    return NO_FLAG;
+}
+/** flag_count: counts the flags which are on in a bitflag set. */
+export function flagCount(flags) {
+    let count = 0;
+    for (let i = 0; i < flags.length; i++) {
+        for (let j = 1; j <= FLAG_WIDTH; j++) {
+            if ((flags[i] & flagBinary(j)) !== 0)
+                count++;
+        }
+    }
+    return count;
+}
+/** flag_is_empty: true when no flags are set. */
+export function flagIsEmpty(flags) {
+    for (let i = 0; i < flags.length; i++) {
+        if (flags[i] > 0)
+            return false;
+    }
+    return true;
+}
+/**
+ * flag_is_full: true when all flags are set. As upstream, this checks whole
+ * bytes (0xff), so trailing padding bits beyond the last real flag count.
+ */
+export function flagIsFull(flags) {
+    for (let i = 0; i < flags.length; i++) {
+        if (flags[i] !== 0xff)
+            return false;
+    }
+    return true;
+}
+/** flag_is_inter: true when any flag is set in both sets. */
+export function flagIsInter(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagIsInter");
+    for (let i = 0; i < flags1.length; i++) {
+        if ((flags1[i] & flags2[i]) !== 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * flag_is_subset: true when every set flag in flags2 is also set in flags1
+ * (i.e. flags2 is a subset of flags1). Argument order follows upstream.
+ */
+export function flagIsSubset(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagIsSubset");
+    for (let i = 0; i < flags1.length; i++) {
+        if ((~flags1[i] & flags2[i]) !== 0)
+            return false;
+    }
+    return true;
+}
+/** flag_is_equal: true when both sets have identical flags. */
+export function flagIsEqual(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagIsEqual");
+    for (let i = 0; i < flags1.length; i++) {
+        if (flags1[i] !== flags2[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * flag_on: sets one flag. Returns true when a change was made, false when
+ * the flag was already set.
+ */
+export function flagOn(flags, flag) {
+    assertValidFlag(flags, flag, "flagOn");
+    const offset = flagOffset(flag);
+    const binary = flagBinary(flag);
+    if ((flags[offset] & binary) !== 0)
+        return false;
+    flags[offset] = flags[offset] | binary;
+    return true;
+}
+/**
+ * flag_off: clears one flag. Returns true when a change was made, false
+ * when the flag was already clear.
+ */
+export function flagOff(flags, flag) {
+    assertValidFlag(flags, flag, "flagOff");
+    const offset = flagOffset(flag);
+    const binary = flagBinary(flag);
+    if ((flags[offset] & binary) === 0)
+        return false;
+    flags[offset] = flags[offset] & ~binary & 0xff;
+    return true;
+}
+/** flag_wipe: clears all flags. */
+export function flagWipe(flags) {
+    flags.fill(0);
+}
+/** flag_setall: sets all flags (whole bytes, as upstream memset 255). */
+export function flagSetall(flags) {
+    flags.fill(0xff);
+}
+/** flag_negate: toggles all flags. */
+export function flagNegate(flags) {
+    for (let i = 0; i < flags.length; i++) {
+        flags[i] = ~flags[i] & 0xff;
+    }
+}
+/** flag_copy: copies flags2 into flags1. */
+export function flagCopy(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagCopy");
+    flags1.set(flags2);
+}
+/**
+ * flag_union: flags1 |= flags2. Returns true when changes were made (some
+ * flag of flags2 was not already set in flags1).
+ */
+export function flagUnion(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagUnion");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const b = flags2[i];
+        if ((~a & b) !== 0)
+            delta = true;
+        flags1[i] = (a | b) & 0xff;
+    }
+    return delta;
+}
+/**
+ * flag_inter: flags1 &= flags2. Upstream quirk kept faithfully: the return
+ * value reports whether flags1 and flags2 DIFFERED (per byte), not whether
+ * flags1 was actually modified. E.g. flags1 = 0x01, flags2 = 0x03 returns
+ * true even though flags1 is unchanged.
+ */
+export function flagInter(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagInter");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const b = flags2[i];
+        if (a !== b)
+            delta = true;
+        flags1[i] = a & b;
+    }
+    return delta;
+}
+/**
+ * flag_diff: flags1 &= ~flags2 (clears every flag set in flags2). Returns
+ * true when changes were made (the sets intersected).
+ */
+export function flagDiff(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagDiff");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const b = flags2[i];
+        if ((a & b) !== 0)
+            delta = true;
+        flags1[i] = a & ~b & 0xff;
+    }
+    return delta;
+}
+/**
+ * flag_comp_union: flags1 |= ~flags2 (union with the complement of flags2).
+ * Not defined upstream (see module docs); returns true when flags1 changed.
+ */
+export function flagCompUnion(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagCompUnion");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const nb = ~flags2[i] & 0xff;
+        if ((~a & nb) !== 0)
+            delta = true;
+        flags1[i] = (a | nb) & 0xff;
+    }
+    return delta;
+}
+/**
+ * flag_comp_inter: flags1 &= ~flags2 (intersection with the complement of
+ * flags2, i.e. the same mutation as flagDiff). Not defined upstream; returns
+ * true when flags1 changed.
+ */
+export function flagCompInter(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagCompInter");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const nb = ~flags2[i] & 0xff;
+        if ((a & ~nb) !== 0)
+            delta = true;
+        flags1[i] = a & nb;
+    }
+    return delta;
+}
+/**
+ * flag_comp_diff: flags1 &= ~(~flags2), i.e. flags1 &= flags2 (difference
+ * with the complement of flags2, the same mutation as flagInter). Not
+ * defined upstream; returns true when flags1 changed (NOT the flagInter
+ * inequality quirk).
+ */
+export function flagCompDiff(flags1, flags2) {
+    assertSameSize(flags1, flags2, "flagCompDiff");
+    let delta = false;
+    for (let i = 0; i < flags1.length; i++) {
+        const a = flags1[i];
+        const b = flags2[i];
+        if ((a & ~b) !== 0)
+            delta = true;
+        flags1[i] = a & b;
+    }
+    return delta;
+}
+/**
+ * flags_test: true if any of the given flags are set. Upstream is variadic
+ * with a FLAG_END terminator; this port takes rest parameters.
+ */
+export function flagsTest(flags, ...check) {
+    for (const f of check) {
+        if (flagHas(flags, f))
+            return true;
+    }
+    return false;
+}
+/** flags_test_all: true if all of the given flags are set. */
+export function flagsTestAll(flags, ...check) {
+    for (const f of check) {
+        if (!flagHas(flags, f))
+            return false;
+    }
+    return true;
+}
+/**
+ * flags_clear: clears the given flags. Returns true when changes were made.
+ */
+export function flagsClear(flags, ...clear) {
+    let delta = false;
+    for (const f of clear) {
+        if (flagOff(flags, f))
+            delta = true;
+    }
+    return delta;
+}
+/** flags_set: sets the given flags. Returns true when changes were made. */
+export function flagsSet(flags, ...set) {
+    let delta = false;
+    for (const f of set) {
+        if (flagOn(flags, f))
+            delta = true;
+    }
+    return delta;
+}
+/** flags_init: wipes the set, then sets the given flags. */
+export function flagsInit(flags, ...set) {
+    flagWipe(flags);
+    for (const f of set)
+        flagOn(flags, f);
+}
+/**
+ * flags_mask: clears the flags NOT given (intersects with a mask built from
+ * the given flags). Return value keeps the upstream flag_inter inequality
+ * quirk, because upstream implements this via flag_inter.
+ */
+export function flagsMask(flags, ...mask) {
+    const m = new Uint8Array(flags.length);
+    for (const f of mask)
+        flagOn(m, f);
+    return flagInter(flags, m);
+}
+/**
+ * An object wrapper around a Uint8Array flag set with the upstream API as
+ * methods. Sizes are byte sizes, exactly like the upstream `size`
+ * parameters; use FlagSet.forFlags(maxFlag) to size a set by its highest
+ * flag value (the equivalent of bitflag name[FLAG_SIZE(MAX)]).
+ */
+export class FlagSet {
+    bits;
+    constructor(size) {
+        if (typeof size === "number") {
+            if (size < 1 || !Number.isInteger(size)) {
+                throw new RangeError(`FlagSet: invalid byte size ${size}`);
+            }
+            this.bits = new Uint8Array(size);
+        }
+        else {
+            this.bits = size;
+        }
+    }
+    /** Size a set to hold flags FLAG_START..maxFlag - 1 (FLAG_SIZE(max)). */
+    static forFlags(maxFlag) {
+        return new FlagSet(flagSize(maxFlag));
+    }
+    /** The byte size of the set (the upstream `size` parameter). */
+    get size() {
+        return this.bits.length;
+    }
+    has(flag) {
+        return flagHas(this.bits, flag);
+    }
+    /** Next on flag at or after `flag`; NO_FLAG when exhausted. */
+    next(flag) {
+        return flagNext(this.bits, flag);
+    }
+    count() {
+        return flagCount(this.bits);
+    }
+    isEmpty() {
+        return flagIsEmpty(this.bits);
+    }
+    isFull() {
+        return flagIsFull(this.bits);
+    }
+    /** True when any flag is set in both this set and `other`. */
+    isInter(other) {
+        return flagIsInter(this.bits, other.bits);
+    }
+    /**
+     * True when `other` is a subset of this set (every flag set in `other`
+     * is also set in this). Mirrors upstream flag_is_subset(this, other).
+     */
+    isSubset(other) {
+        return flagIsSubset(this.bits, other.bits);
+    }
+    isEqual(other) {
+        return flagIsEqual(this.bits, other.bits);
+    }
+    on(flag) {
+        return flagOn(this.bits, flag);
+    }
+    off(flag) {
+        return flagOff(this.bits, flag);
+    }
+    wipe() {
+        flagWipe(this.bits);
+    }
+    setall() {
+        flagSetall(this.bits);
+    }
+    negate() {
+        flagNegate(this.bits);
+    }
+    /** Copies `other` into this set (upstream flag_copy(this, other)). */
+    copy(other) {
+        flagCopy(this.bits, other.bits);
+    }
+    /** A new FlagSet with the same contents. */
+    clone() {
+        return new FlagSet(Uint8Array.from(this.bits));
+    }
+    union(other) {
+        return flagUnion(this.bits, other.bits);
+    }
+    inter(other) {
+        return flagInter(this.bits, other.bits);
+    }
+    diff(other) {
+        return flagDiff(this.bits, other.bits);
+    }
+    compUnion(other) {
+        return flagCompUnion(this.bits, other.bits);
+    }
+    compInter(other) {
+        return flagCompInter(this.bits, other.bits);
+    }
+    compDiff(other) {
+        return flagCompDiff(this.bits, other.bits);
+    }
+    test(...check) {
+        return flagsTest(this.bits, ...check);
+    }
+    testAll(...check) {
+        return flagsTestAll(this.bits, ...check);
+    }
+    clear(...clear) {
+        return flagsClear(this.bits, ...clear);
+    }
+    set(...set) {
+        return flagsSet(this.bits, ...set);
+    }
+    init(...set) {
+        flagsInit(this.bits, ...set);
+    }
+    mask(...mask) {
+        return flagsMask(this.bits, ...mask);
+    }
+    /** Iterate the set flags in ascending order. */
+    *[Symbol.iterator]() {
+        for (let f = flagNext(this.bits, FLAG_START); f !== NO_FLAG; f = flagNext(this.bits, f + 1)) {
+            yield f;
+        }
+    }
+}
+//# sourceMappingURL=bitflag.js.map