aviation-chart 2.0.34 → 2.0.36

package/dist/nav-sdk.d.ts

@@ -965,6 +965,7 @@ declare class MapSDK implements IMapSDK {
     private _apiVersion;
     private _tileCipher;
     private _stopAMMVersioning;
+    private _navDataVersioning;
     readonly ready: Promise<void>;
     private _resolveReady;
     private _rejectReady;

package/dist/nav-sdk.esm.js

@@ -2029,7 +2029,7 @@ const AMM_LAYER_GROUPS = {
   ammHolding: ['amm-holding', 'amm-holding-label'],
   ammStand: ['amm-stand-label', 'amm-stand-line'],
   ammRestricted: ['amm-restricted-fill'],
-  ammHotspot: ['amm-hotspot-fill'],
+  ammHotspot: ['amm-hotspot-fill', 'amm-hotpost-label'],
   /** 障碍物（点 + 面） */
   ammObstacle: ['amm-obstacle-region-fill', 'amm-obstacle-point-label'],
   ammConstruction: ['amm-construction-fill', 'amm-construction-stroke', 'amm-construction-label'],
@@ -7713,9 +7713,13 @@ function isBytes$1(a) {
             'BYTES_PER_ELEMENT' in a &&
             a.BYTES_PER_ELEMENT === 1));
 }
+// Shared error-message prefix builder. Only called on throw paths, so assert
+// success paths never pay for the string concatenation.
+const atitle$1 = (title) => (title ? `"${title}" ` : '');
 /**
  * Asserts something is boolean.
- * @param b - Value to validate.
+ * @param value - Value to validate.
+ * @returns The validated boolean.
  * @throws On wrong argument types. {@link TypeError}
  * @example
  * Validates a boolean option before branching on it.
@@ -7724,13 +7728,15 @@ function isBytes$1(a) {
  * abool(true);
  * ```
  */
-function abool(b) {
-    if (typeof b !== 'boolean')
-        throw new TypeError(`boolean expected, not ${b}`);
+function abool(value, title = '') {
+    if (typeof value !== 'boolean')
+        throw new TypeError(atitle$1(title) + 'expected boolean, got type=' + typeof value);
+    return value;
 }
 /**
  * Asserts something is a non-negative safe integer.
  * @param n - Value to validate.
+ * @returns The validated number.
  * @throws On wrong argument types. {@link TypeError}
  * @throws On wrong argument ranges or values. {@link RangeError}
  * @example
@@ -7740,11 +7746,12 @@ function abool(b) {
  * anumber(1);
  * ```
  */
-function anumber$1(n) {
+function anumber$1(n, title = '') {
     if (typeof n !== 'number')
-        throw new TypeError('number expected, got ' + typeof n);
+        throw new TypeError(atitle$1(title) + 'expected number, got ' + typeof n);
     if (!Number.isSafeInteger(n) || n < 0)
-        throw new RangeError('positive integer expected, got ' + n);
+        throw new RangeError(atitle$1(title) + 'expected integer >= 0, got ' + n);
+    return n;
 }
 /**
  * Asserts something is Uint8Array.
@@ -7763,19 +7770,20 @@ function anumber$1(n) {
  * ```
  */
 function abytes$1(value, length, title = '') {
+    // Success path first: this runs at the start of every update() / digestInto(), and the
+    // common `abytes(data)` form must not pay for length handling it does not use.
+    if (isBytes$1(value) && (length === undefined || value.length === length))
+        return value;
+    // Error path: recompute freely to build the exact message.
+    if (length !== undefined)
+        anumber$1(length, 'length');
     const bytes = isBytes$1(value);
-    const len = value?.length;
-    const needsLen = length !== undefined;
-    if (!bytes || (needsLen && len !== length)) {
-        const prefix = title && `"${title}" `;
-        const ofLen = needsLen ? ` of length ${length}` : '';
-        const got = bytes ? `length=${len}` : `type=${typeof value}`;
-        const message = prefix + 'expected Uint8Array' + ofLen + ', got ' + got;
-        if (!bytes)
-            throw new TypeError(message);
-        throw new RangeError(message);
-    }
-    return value;
+    const ofLen = length !== undefined ? ` of length ${length}` : '';
+    const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+    const message = atitle$1(title) + 'expected Uint8Array' + ofLen + ', got ' + got;
+    if (!bytes)
+        throw new TypeError(message);
+    throw new RangeError(message);
 }
 /**
  * Asserts a hash- or MAC-like instance has not been destroyed or finished.
@@ -7791,21 +7799,21 @@ function abytes$1(value, length, title = '') {
  * ```
  */
 function aexists$1(instance, checkFinished = true) {
+    // Runs on every update()/digestInto(); the flags are library-owned booleans, so only their
+    // truthiness is checked - re-validating their type per call was pure hot-path overhead.
     if (instance.destroyed)
-        throw new Error('Hash instance has been destroyed');
+        throw new Error('hash was destroyed');
     if (checkFinished && instance.finished)
-        throw new Error('Hash#digest() has already been called');
+        throw new Error('digest() was already called');
 }
 /**
- * Asserts output is a properly-sized byte array.
+ * Asserts output is a sufficiently-sized byte array.
  * @param out - Output buffer to validate.
  * @param instance - Hash-like instance providing `outputLen`.
  * This is the relaxed `digestInto()`-style contract: output must be at least `outputLen`,
  * unlike one-shot cipher helpers elsewhere in the repo that often require exact lengths.
  * @throws On wrong argument types. {@link TypeError}
- * @param onlyAligned - Whether `out` must be 4-byte aligned for zero-allocation word views.
  * @throws On wrong output buffer lengths. {@link RangeError}
- * @throws On wrong output buffer alignment. {@link Error}
  * @example
  * Verifies that a caller-provided output buffer is large enough.
  *
@@ -7813,13 +7821,34 @@ function aexists$1(instance, checkFinished = true) {
  * aoutput(new Uint8Array(16), { outputLen: 16 });
  * ```
  */
-function aoutput$1(out, instance, onlyAligned = false) {
+function aoutput$1(out, instance) {
     abytes$1(out, undefined, 'output');
+    // `outputLen` is a library-owned readonly number; the negated comparison keeps failing fast
+    // when it is missing/NaN (comparisons with undefined/NaN are false) without an anumber() call.
     const min = instance.outputLen;
-    if (out.length < min) {
-        throw new RangeError('digestInto() expects output buffer of length at least ' + min);
+    if (!(out.length >= min)) {
+        throw new RangeError('"output" expected length >= ' + min);
     }
-    if (onlyAligned && !isAligned32(out))
+}
+/**
+ * Asserts output is a sufficiently-sized, 4-byte-aligned byte array.
+ * {@link aoutput} plus an {@link isAligned32} check, for `digestInto()` paths
+ * that write through zero-allocation `u32` word views.
+ * @param out - Output buffer to validate.
+ * @param instance - Hash-like instance providing `outputLen`.
+ * @throws On wrong argument types. {@link TypeError}
+ * @throws On wrong output buffer lengths. {@link RangeError}
+ * @throws On wrong output buffer alignment. {@link Error}
+ * @example
+ * Verifies that a caller-provided output buffer is large enough and aligned.
+ *
+ * ```ts
+ * aoutput32(new Uint8Array(16), { outputLen: 16 });
+ * ```
+ */
+function aoutput32(out, instance) {
+    aoutput$1(out, instance);
+    if (!isAligned32(out))
         throw new Error('invalid output, must be aligned');
 }
 /**
@@ -7898,10 +7927,12 @@ const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344])
  * byteSwap(0x11223344);
  * ```
  */
-const byteSwap = (word) => ((word << 24) & 0xff000000) |
-    ((word << 8) & 0xff0000) |
-    ((word >>> 8) & 0xff00) |
-    ((word >>> 24) & 0xff);
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
 /**
  * Normalizes one 32-bit word to the little-endian representation expected by cipher cores.
  * @param n - Unsigned 32-bit word to normalize.
@@ -7927,11 +7958,12 @@ const swap8IfBE = isLE
  * byteSwap32(new Uint32Array([0x11223344]));
  * ```
  */
-const byteSwap32 = (arr) => {
-    for (let i = 0; i < arr.length; i++)
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
         arr[i] = byteSwap(arr[i]);
+    }
     return arr;
-};
+}
 /**
  * Normalizes a Uint32Array view to the little-endian representation expected by cipher cores.
  * @param u - Word view to normalize in place.
@@ -7959,6 +7991,8 @@ const swap32IfBE = isLE
  * ```
  */
 function equalBytes(a, b) {
+    a = abytes$1(a);
+    b = abytes$1(b);
     if (a.length !== b.length)
         return false;
     let diff = 0;
@@ -7991,8 +8025,9 @@ function wrapMacConstructor(keyLen, macCons, fromMsg) {
  * Wraps a cipher: validates args, ensures encrypt() can only be called once.
  * Used internally by the exported cipher constructors.
  * Output-buffer support is inferred from the wrapped `encrypt` / `decrypt`
- * arity (`fn.length === 2`), and tag-bearing constructors are expected to use
- * `args[1]` for optional AAD.
+ * arity (`fn.length === 2`), so wrapped output-capable methods must use a normal
+ * second parameter, not a default/rest parameter. AAD support is explicit in
+ * `params.withAAD`; optional AAD starts after the nonce slot when one is present.
  * @__NO_SIDE_EFFECTS__
  * @param params - Static cipher metadata. See {@link CipherParams}.
  * @param constructor - Cipher constructor.
@@ -8007,10 +8042,18 @@ const wrapCipher = (params, constructor) => {
             const nonce = args[0];
             abytes$1(nonce, params.varSizeNonce ? undefined : params.nonceLength, 'nonce');
         }
-        // Validate AAD if tagLength present
+        // Keep tag length available for decrypt-size checks after constructor validation.
         const tagl = params.tagLength;
-        if (tagl && args[1] !== undefined)
-            abytes$1(args[1], undefined, 'AAD');
+        const aadStart = params.nonceLength !== undefined ? 1 : 0;
+        // No-AAD constructors otherwise silently ignore byte args meant as AAD.
+        if (!params.withAAD) {
+            for (let i = aadStart; i < args.length; i++)
+                if (isBytes$1(args[i]))
+                    throw new Error('AAD not supported');
+        }
+        // Validate the first AAD slot early; rest-arg AAD constructors validate the tail themselves.
+        if (params.withAAD && args[aadStart] !== undefined)
+            abytes$1(args[aadStart], undefined, 'AAD');
         const cipher = constructor(key, ...args);
         const checkOutput = (fnLength, output) => {
             if (output !== undefined) {
@@ -8025,15 +8068,16 @@ const wrapCipher = (params, constructor) => {
             encrypt(data, output) {
                 if (called)
                     throw new Error('cannot encrypt() twice with same key + nonce');
+                // Any encrypt attempt consumes the instance, even if validation rejects below.
                 called = true;
-                abytes$1(data);
+                abytes$1(data, undefined, 'data');
                 checkOutput(cipher.encrypt.length, output);
                 return cipher.encrypt(data, output);
             },
             decrypt(data, output) {
-                abytes$1(data);
+                abytes$1(data, undefined, 'data');
                 if (tagl && data.length < tagl)
-                    throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl);
+                    throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
                 checkOutput(cipher.decrypt.length, output);
                 return cipher.decrypt(data, output);
             },
@@ -8051,7 +8095,8 @@ const wrapCipher = (params, constructor) => {
  * @param onlyAligned - Whether `out` must be 4-byte aligned.
  * @returns Output buffer ready for writing.
  * @throws On wrong argument types. {@link TypeError}
- * @throws If the provided output buffer has the wrong size or alignment. {@link Error}
+ * @throws If the provided output buffer has the wrong size. {@link RangeError}
+ * @throws If the provided output buffer has the wrong alignment. {@link Error}
  * @example
  * Reuses a caller-provided output buffer when lengths match.
  *
@@ -8063,17 +8108,16 @@ function getOutput(expectedLength, out, onlyAligned = true) {
     if (out === undefined)
         return new Uint8Array(expectedLength);
     // Keep Buffer/cross-realm Uint8Array support here instead of trusting a shape-compatible object.
-    abytes$1(out, undefined, 'output');
-    if (out.length !== expectedLength)
-        throw new Error('"output" expected Uint8Array of length ' + expectedLength + ', got: ' + out.length);
+    abytes$1(out, expectedLength, 'output');
     if (onlyAligned && !isAligned32(out))
         throw new Error('invalid output, must be aligned');
     return out;
 }
 /**
- * Encodes data and AAD bit lengths into a 16-byte buffer.
- * @param dataLength - Data length in bits.
- * @param aadLength - AAD length in bits.
+ * Encodes data and AAD lengths into a 16-byte buffer.
+ * @param dataLength - Data length. Units are caller-defined: GCM passes bit
+ * lengths, ChaCha20-Poly1305 passes byte lengths — the helper writes the raw values.
+ * @param aadLength - AAD length, same unit convention as `dataLength`.
  * The serialized block is still `aadLength || dataLength`, matching GCM/Poly1305
  * conventions even though the helper parameter order is `(dataLength, aadLength)`.
  * @param isLE - Whether to encode lengths as little-endian.
@@ -8315,7 +8359,7 @@ class GHASH {
         aexists$1(this);
         // `digestInto(out)` is the no-allocation fast path, so callers must pass a
         // 32-bit-aligned buffer before we reinterpret it with `u32(out)`.
-        aoutput$1(out, this, true);
+        aoutput32(out, this);
         this.finished = true;
         // NIST SP 800-38D §6.4 returns the final 128-bit block Y_m.
         // `digestInto()` follows the relaxed `aoutput()` contract, so only
@@ -8326,7 +8370,9 @@ class GHASH {
         o32[1] = s1;
         o32[2] = s2;
         o32[3] = s3;
-        swap32IfBE(o32);
+        // Only the tag words need host-endian normalization; oversized output tails are caller-owned.
+        if (!isLE)
+            swap32IfBE(o32.subarray(0, BLOCK_SIZE$1 / 4));
     }
     digest() {
         const res = new Uint8Array(BLOCK_SIZE$1);
@@ -8440,7 +8486,7 @@ const rotl32_8 = (n) => (n << 8) | (n >>> 24);
 //   so index is u16, instead of u8. This speeds up things, unexpectedly
 function genTtable(sbox, fn) {
     if (sbox.length !== 256)
-        throw new Error('Wrong sbox length');
+        throw new Error('wrong sbox length');
     const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));
     const T1 = T0.map(rotl32_8);
     const T2 = T1.map(rotl32_8);
@@ -8559,22 +8605,21 @@ function ctr32(xk, isLE, nonce, src, dst) {
     // RFC 8452 AES-GCM-SIV increments the first 32 bits as a little-endian u32.
     const ctrPos = isLE ? 0 : 12;
     const srcLen = src.length;
-    // Fill block (empty, ctr=0)
     let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value
-    let { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
     // process blocks
     for (let i = 0; i + 4 <= src32.length; i += 4) {
+        const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
         dst32[i + 0] = src32[i + 0] ^ swap8IfBE(s0);
         dst32[i + 1] = src32[i + 1] ^ swap8IfBE(s1);
         dst32[i + 2] = src32[i + 2] ^ swap8IfBE(s2);
         dst32[i + 3] = src32[i + 3] ^ swap8IfBE(s3);
         ctrNum = (ctrNum + 1) >>> 0; // u32 wrap
         view.setUint32(ctrPos, ctrNum, isLE);
-        ({ s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3])));
     }
     // leftovers (less than a block)
     const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
     if (start < srcLen) {
+        const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
         const b32 = new Uint32Array([s0, s1, s2, s3]);
         swap32IfBE(b32);
         const buf = u8$1(b32);
@@ -8623,11 +8668,12 @@ function computeTag(fn, isLE, key, data, AAD) {
  * import { randomBytes } from '@noble/ciphers/utils.js';
  * const key = randomBytes(16);
  * const nonce = randomBytes(12);
- * const cipher = gcm(key, nonce);
+ * const aad = new TextEncoder().encode('session metadata');
+ * const cipher = gcm(key, nonce, aad);
  * cipher.encrypt(new Uint8Array([1, 2, 3]));
  * ```
  */
-const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
+const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, withAAD: true, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
     // SP 800-38D lets implementations narrow supported IV lengths.
     // This wrapper intentionally requires at least 8 bytes; OpenSSL accepts shorter IVs too.
     // 12-byte nonces take the fast path; other allowed lengths use GHASH to derive J0.
@@ -8693,7 +8739,7 @@ const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLeng
             // tag before CTR so unauthenticated plaintext is never materialized.
             if (!equalBytes(tag, passedTag)) {
                 clean$1(...toClean);
-                throw new Error('aes/gcm: invalid ghash tag');
+                throw new Error('aes-gcm: invalid tag');
             }
             const out = ctr32(xk, false, counter, data);
             clean$1(...toClean);
@@ -8723,10 +8769,14 @@ function isBytes(a) {
             'BYTES_PER_ELEMENT' in a &&
             a.BYTES_PER_ELEMENT === 1));
 }
+// Shared error-message prefix builder. Only called on throw paths, so assert
+// success paths never pay for the string concatenation.
+const atitle = (title) => (title ? `"${title}" ` : '');
 /**
  * Asserts something is a non-negative integer.
  * @param n - number to validate
  * @param title - label included in thrown errors
+ * @returns The validated number.
  * @throws On wrong argument types. {@link TypeError}
  * @throws On wrong argument ranges or values. {@link RangeError}
  * @example
@@ -8736,14 +8786,11 @@ function isBytes(a) {
  * ```
  */
 function anumber(n, title = '') {
-    if (typeof n !== 'number') {
-        const prefix = title && `"${title}" `;
-        throw new TypeError(`${prefix}expected number, got ${typeof n}`);
-    }
-    if (!Number.isSafeInteger(n) || n < 0) {
-        const prefix = title && `"${title}" `;
-        throw new RangeError(`${prefix}expected integer >= 0, got ${n}`);
-    }
+    if (typeof n !== 'number')
+        throw new TypeError(atitle(title) + 'expected number, got ' + typeof n);
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new RangeError(atitle(title) + 'expected integer >= 0, got ' + n);
+    return n;
 }
 /**
  * Asserts something is Uint8Array.
@@ -8760,19 +8807,20 @@ function anumber(n, title = '') {
  * ```
  */
 function abytes(value, length, title = '') {
+    // Success path first: this runs at the start of every update() / digestInto(), and the
+    // common `abytes(data)` form must not pay for length handling it does not use.
+    if (isBytes(value) && (length === undefined || value.length === length))
+        return value;
+    // Error path: recompute freely to build the exact message.
+    if (length !== undefined)
+        anumber(length, 'length');
     const bytes = isBytes(value);
-    const len = value?.length;
-    const needsLen = length !== undefined;
-    if (!bytes || (needsLen && len !== length)) {
-        const prefix = title && `"${title}" `;
-        const ofLen = needsLen ? ` of length ${length}` : '';
-        const got = bytes ? `length=${len}` : `type=${typeof value}`;
-        const message = prefix + 'expected Uint8Array' + ofLen + ', got ' + got;
-        if (!bytes)
-            throw new TypeError(message);
-        throw new RangeError(message);
-    }
-    return value;
+    const ofLen = length !== undefined ? ` of length ${length}` : '';
+    const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+    const message = atitle(title) + 'expected Uint8Array' + ofLen + ', got ' + got;
+    if (!bytes)
+        throw new TypeError(message);
+    throw new RangeError(message);
 }
 /**
  * Asserts something is a wrapped hash constructor.
@@ -8790,16 +8838,28 @@ function abytes(value, length, title = '') {
  */
 function ahash(h) {
     if (typeof h !== 'function' || typeof h.create !== 'function')
-        throw new TypeError('Hash must wrapped by utils.createHasher');
+        throw new TypeError('expected hash wrapped by utils.createHasher');
     anumber(h.outputLen);
     anumber(h.blockLen);
     // HMAC and KDF callers treat these as real byte lengths; allowing zero lets fake wrappers pass
     // validation and can produce empty outputs instead of failing fast.
-    if (h.outputLen < 1)
-        throw new Error('"outputLen" must be >= 1');
-    if (h.blockLen < 1)
-        throw new Error('"blockLen" must be >= 1');
+    if (h.outputLen < 1 || h.blockLen < 1)
+        throw new Error('hash blockLen / outputLen must be >= 1');
 }
+const aobject = (value, label) => {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError((label === 'object' ? '' : `"${label}" `) + 'expected object, got type=' + typeof value);
+};
+const aopts = (value, label) => {
+    aobject(value, label);
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+        throw new TypeError(`"${label}" expected plain object`);
+    // Object.assign() treats an own "__proto__" source key as a write to the target's legacy
+    // prototype setter. Reject it before merging so inherited option values cannot be injected.
+    if (Object.hasOwn(value, '__proto__'))
+        throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
 /**
  * Asserts a hash instance has not been destroyed or finished.
  * @param instance - hash instance to validate
@@ -8815,10 +8875,12 @@ function ahash(h) {
  * ```
  */
 function aexists(instance, checkFinished = true) {
+    // Runs on every update()/digestInto(); the flags are library-owned booleans, so only their
+    // truthiness is checked - re-validating their type per call was pure hot-path overhead.
     if (instance.destroyed)
-        throw new Error('Hash instance has been destroyed');
+        throw new Error('hash was destroyed');
     if (checkFinished && instance.finished)
-        throw new Error('Hash#digest() has already been called');
+        throw new Error('digest() was already called');
 }
 /**
  * Asserts output is a sufficiently-sized byte array.
@@ -8837,10 +8899,12 @@ function aexists(instance, checkFinished = true) {
  * ```
  */
 function aoutput(out, instance) {
-    abytes(out, undefined, 'digestInto() output');
+    abytes(out, undefined, 'output');
+    // `outputLen` is a library-owned readonly number; the negated comparison keeps failing fast
+    // when it is missing/NaN (comparisons with undefined/NaN are false) without an anumber() call.
     const min = instance.outputLen;
-    if (out.length < min) {
-        throw new RangeError('"digestInto() output" expected to be of length >=' + min);
+    if (!(out.length >= min)) {
+        throw new RangeError('"output" expected length >= ' + min);
     }
 }
 /**
@@ -8884,6 +8948,28 @@ function createView(arr) {
 function rotr(word, shift) {
     return (word << (32 - shift)) | (word >>> shift);
 }
+/**
+ * Merges default options and passed options.
+ * @param defaults - base option object
+ * @param opts - user overrides
+ * @param title - label included in thrown override errors
+ * @returns Fresh merged option object with a null prototype.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Merge user overrides onto default options.
+ * ```ts
+ * checkOpts({ dkLen: 32 }, { asyncTick: 10 });
+ * ```
+ */
+function checkOpts(defaults, opts, title = 'opts') {
+    aopts(defaults, 'defaults');
+    if (opts !== undefined)
+        aopts(opts, title);
+    // Callers read optional fields directly, so omitted values must not fall through to ambient
+    // Object.prototype pollution (for example a forged `dkLen` changing SHAKE's default output).
+    const merged = Object.assign(Object.create(null), defaults, opts);
+    return merged;
+}
 /**
  * Creates a callable hash function from a stateful class constructor.
  * @param hashCons - hash constructor or factory
@@ -8892,6 +8978,7 @@ function rotr(word, shift) {
  *   Wrapper construction eagerly calls `hashCons(undefined)` once to read
  *   `outputLen` / `blockLen`, so constructor side effects happen at module
  *   init time.
+ * @throws On wrong argument types. {@link TypeError}
  * @example
  * Wrap a stateful hash constructor into a callable helper.
  * ```ts
@@ -8902,6 +8989,9 @@ function rotr(word, shift) {
  * ```
  */
 function createHasher(hashCons, info = {}) {
+    if (typeof hashCons !== 'function')
+        throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+    info = checkOpts({}, info, 'info');
     const hashC = (msg, opts) => hashCons(opts)
         .update(msg)
         .digest();
@@ -8953,7 +9043,7 @@ class _HMAC {
         abytes(key, undefined, 'key');
         this.iHash = hash.create();
         if (typeof this.iHash.update !== 'function')
-            throw new Error('Expected instance of class which extends utils.Hash');
+            throw new Error('expected Hash instance');
         this.blockLen = this.iHash.blockLen;
         this.outputLen = this.iHash.outputLen;
         const blockLen = this.blockLen;
@@ -8998,12 +9088,13 @@ class _HMAC {
         // Create new instance without calling constructor since the key
         // is already in state and we don't know it.
         to ||= Object.create(Object.getPrototypeOf(this), {});
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
         to = to;
         to.finished = finished;
         to.destroyed = destroyed;
         to.blockLen = blockLen;
         to.outputLen = outputLen;
+        to.canXOF = canXOF;
         to.oHash = oHash._cloneInto(to.oHash);
         to.iHash = iHash._cloneInto(to.iHash);
         return to;
@@ -9023,6 +9114,20 @@ const hmac = /* @__PURE__ */ (() => {
     return hmac_;
 })();
 
+// Split a JS number into u32 halves without a BigInt allocation. Exact only for integers
+// `0 <= n < 2**53`; callers use it on byte / bit counters, which JS length math caps far below
+// that (an ArrayBuffer cannot exceed 2**53 - 1 bytes).
+const fromNumH = (n) => (n / 2 ** 32) | 0;
+const fromNumL = (n) => n >>> 0;
+// Drop-in replacement for `view.setBigUint64(byteOffset, BigInt(n), isLE)` without the per-call
+// BigInt allocation. Same `n < 2**53` precondition as `fromNumH`/`fromNumL`.
+function setU64FromNum(view, byteOffset, n, isLE) {
+    const h = fromNumH(n);
+    const l = fromNumL(n);
+    view.setUint32(byteOffset, isLE ? l : h, isLE);
+    view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+
 /**
  * Internal Merkle-Damgard hash utils.
  * @module
@@ -9105,6 +9210,7 @@ class HashMD {
         abytes(data);
         const { view, buffer, blockLen } = this;
         const len = data.length;
+        let processed = false;
         for (let pos = 0; pos < len;) {
             const take = Math.min(blockLen - this.pos, len - pos);
             // Fast path only when there is no buffered partial block: `take === blockLen` implies
@@ -9113,18 +9219,25 @@ class HashMD {
                 const dataView = createView(data);
                 for (; blockLen <= len - pos; pos += blockLen)
                     this.process(dataView, pos);
+                processed = true;
                 continue;
             }
-            buffer.set(data.subarray(pos, pos + take), this.pos);
+            // When the whole input is buffered in one go (common for short messages), passing `data`
+            // directly avoids allocating a subarray view.
+            buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
             this.pos += take;
             pos += take;
             if (this.pos === blockLen) {
                 this.process(view, 0);
                 this.pos = 0;
+                processed = true;
             }
         }
         this.length += data.length;
-        this.roundClean();
+        // Shared schedule buffers only pick up input-derived words inside process(); if everything
+        // was buffered without processing, there is nothing to zero.
+        if (processed)
+            this.roundClean();
         return this;
     }
     digestInto(out) {
@@ -9136,32 +9249,33 @@ class HashMD {
         // was previously not allocated here. But it won't change performance.
         const { buffer, view, blockLen, isLE } = this;
         let { pos } = this;
-        // append the bit '1' to the message
+        // append the bit '1' to the message, then zero-pad the rest of the block
         buffer[pos++] = 0b10000000;
-        clean(this.buffer.subarray(pos));
+        buffer.fill(0, pos);
         // we have less than padOffset left in buffer, so we cannot put length in
         // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
             this.process(view, 0);
-            pos = 0;
+            buffer.fill(0);
         }
-        // Pad until full block byte with zeros
-        for (let i = pos; i < blockLen; i++)
-            buffer[i] = 0;
         // `padOffset` reserves the whole length field. For SHA-384/512 the high 64 bits stay zero from
         // the padding fill above, and JS will overflow before user input can make that half non-zero.
-        // So we only need to write the low 64 bits here.
-        view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+        // So we only need to write the low 64 bits here (`length * 8` only scales the exponent of an
+        // integer below 2**53, so the split inside the helper stays exact).
+        setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
         this.process(view, 0);
-        const oview = createView(out);
+        // The final block above is processed outside update(), so the shared message-schedule
+        // buffers (e.g. SHA256_W) would otherwise retain input-derived words after digest().
+        this.roundClean();
+        // digest() passes our own `buffer` as `out`; reuse its cached view instead of allocating one.
+        const oview = out === buffer ? view : createView(out);
         const len = this.outputLen;
         // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT
-        if (len % 4)
-            throw new Error('_sha2: outputLen must be aligned to 32bit');
         const outLen = len / 4;
         const state = this.get();
-        if (outLen > state.length)
-            throw new Error('_sha2: outputLen bigger than state');
+        // Subclass-misconfiguration invariant: outputLen must be 32-bit aligned and fit the state.
+        if (len % 4 || outLen > state.length)
+            throw new Error('invalid outputLen');
         for (let i = 0; i < outLen; i++)
             oview.setUint32(4 * i, state[i], isLE);
     }
@@ -9174,18 +9288,16 @@ class HashMD {
         this.destroy();
         return res;
     }
-    _cloneInto(to) {
-        to ||= new this.constructor();
-        to.set(...this.get());
-        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    _cloneIntoMeta(to) {
+        const { buffer, length, finished, destroyed, pos } = this;
         to.destroyed = destroyed;
         to.finished = finished;
         to.length = length;
         to.pos = pos;
         // Only partial-block bytes need copying: when `length % blockLen === 0`, `pos === 0` and
         // later `update()` / `digestInto()` overwrite `to.buffer` from the start before reading it.
-        if (length % blockLen)
-            to.buffer.set(buffer);
+        if (pos)
+            to.buffer.set(buffer); // Avoid a hot modulo guard.
         return to;
     }
     clone() {
@@ -9229,8 +9341,28 @@ const SHA256_K = /* @__PURE__ */ Uint32Array.from([
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 /** Internal SHA-224 / SHA-256 compression engine from RFC 6234 §6.2. */
 class SHA2_32B extends HashMD {
-    constructor(outputLen) {
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    // Numeric initializers matter: starting the fields as `undefined` changes
+    // V8's field representation and makes sha256 3x slower (measured).
+    A = 0;
+    B = 0;
+    C = 0;
+    D = 0;
+    E = 0;
+    F = 0;
+    G = 0;
+    H = 0;
+    constructor(outputLen, IV) {
         super(64, outputLen, 8, false);
+        this.A = IV[0] | 0;
+        this.B = IV[1] | 0;
+        this.C = IV[2] | 0;
+        this.D = IV[3] | 0;
+        this.E = IV[4] | 0;
+        this.F = IV[5] | 0;
+        this.G = IV[6] | 0;
+        this.H = IV[7] | 0;
     }
     get() {
         const { A, B, C, D, E, F, G, H } = this;
@@ -9247,6 +9379,10 @@ class SHA2_32B extends HashMD {
         this.G = G | 0;
         this.H = H | 0;
     }
+    _cloneInto(to) {
+        (to ||= new this.constructor()).set(...this.get());
+        return this._cloneIntoMeta(to);
+    }
     process(view, offset) {
         // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
         for (let i = 0; i < 16; i++, offset += 4)
@@ -9298,18 +9434,8 @@ class SHA2_32B extends HashMD {
 }
 /** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */
 class _SHA256 extends SHA2_32B {
-    // We cannot use array here since array allows indexing by variable
-    // which means optimizer/compiler cannot use registers.
-    A = SHA256_IV[0] | 0;
-    B = SHA256_IV[1] | 0;
-    C = SHA256_IV[2] | 0;
-    D = SHA256_IV[3] | 0;
-    E = SHA256_IV[4] | 0;
-    F = SHA256_IV[5] | 0;
-    G = SHA256_IV[6] | 0;
-    H = SHA256_IV[7] | 0;
     constructor() {
-        super(32);
+        super(32, SHA256_IV);
     }
 }
 /**
@@ -9320,6 +9446,7 @@ class _SHA256 extends SHA2_32B {
  * - Each sha256 hash is executing 2^18 bit operations.
  * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
  * @param msg - message bytes to hash
+ * @param opts - Reserved hash options.
  * @returns Digest bytes.
  * @example
  * Hash a message with SHA2-256.
@@ -9846,8 +9973,9 @@ function createTileProtocol(cipher, fetchImpl = fetch) {
             ...(params.headers ? { headers: params.headers } : {}),
             ...(params.credentials ? { credentials: params.credentials } : {}),
         });
-        if (!response.ok)
-            throw new Error(`tile ${response.status}`);
+        if (!response.ok) {
+            throw Object.assign(new Error(`tile ${response.status}`), { status: response.status, url });
+        }
         const envelope = await response.arrayBuffer();
         signal.throwIfAborted();
         const data = envelope.byteLength ? await cipher.decrypt(url, envelope, signal) : new ArrayBuffer(0);
@@ -9923,6 +10051,143 @@ function watchAMMVersion(map, fetchImpl = fetch, intervalMs = 60000) {
     return stop;
 }
 
+function tileIdentity(template) {
+    const http = template.replace(/^kunyu:\/\//, "");
+    const match = /^(https?:\/\/[^?#]+)\/tiles\/(?:e\/)?(\d{6})\//.exec(http);
+    return match ? { prefix: match[1], period: match[2] } : undefined;
+}
+function watchNavDataVersion(map, fetchImpl = fetch, intervalMs = 60000) {
+    let stopped = false;
+    let pending;
+    let observedSource;
+    let observedSignature = "";
+    let lastErrorRefresh = -Infinity;
+    function state() {
+        const source = map.getSource("navdata");
+        const definition = map.getStyle()?.sources.navdata;
+        const tiles = definition?.tiles;
+        const identity = tiles?.[0] && tileIdentity(tiles[0]);
+        if (!source?.setTiles || !tiles?.length || !identity)
+            return undefined;
+        if (!tiles.every(tile => {
+            const other = tileIdentity(tile);
+            return !!other && other.period === identity.period && other.prefix === identity.prefix;
+        }))
+            return undefined;
+        return { source, tiles: [...tiles], signature: JSON.stringify(tiles), ...identity };
+    }
+    function refresh() {
+        if (stopped)
+            return Promise.resolve();
+        const current = state();
+        if (!current) {
+            pending?.controller.abort();
+            return Promise.resolve();
+        }
+        if (pending?.source === current.source && pending.signature === current.signature && !pending.controller.signal.aborted)
+            return pending.promise;
+        pending?.controller.abort();
+        observedSource = current.source;
+        observedSignature = current.signature;
+        const controller = new AbortController();
+        const job = { controller, source: current.source, signature: current.signature, promise: Promise.resolve() };
+        pending = job;
+        job.promise = Promise.resolve().then(async () => {
+            if (stopped || controller.signal.aborted) {
+                if (pending === job)
+                    pending = undefined;
+                return;
+            }
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            try {
+                const response = await fetchImpl(`${current.prefix}/navdata/manifest?period=${current.period}`, {
+                    cache: "no-store", signal: controller.signal,
+                });
+                if (!response.ok)
+                    return;
+                const manifest = await response.json();
+                const latest = state();
+                if (stopped || controller.signal.aborted || latest?.source !== current.source || latest.signature !== current.signature)
+                    return;
+                if (manifest?.available !== true || manifest.period !== current.period || manifest.schemaVersion !== "1" ||
+                    typeof manifest.artifactVersion !== "string" || !manifest.artifactVersion)
+                    return;
+                const next = current.tiles.map(tile => {
+                    const hashAt = tile.indexOf("#");
+                    const hash = hashAt < 0 ? "" : tile.slice(hashAt);
+                    const base = hashAt < 0 ? tile : tile.slice(0, hashAt);
+                    const queryAt = base.indexOf("?");
+                    const path = queryAt < 0 ? base : base.slice(0, queryAt);
+                    const query = new URLSearchParams(queryAt < 0 ? "" : base.slice(queryAt + 1));
+                    query.set("v", manifest.artifactVersion);
+                    return `${path}?${query.toString()}${hash}`;
+                });
+                const signature = JSON.stringify(next);
+                if (signature === current.signature)
+                    return;
+                observedSource = current.source;
+                observedSignature = signature;
+                current.source.setTiles(next);
+            }
+            catch {
+            }
+            finally {
+                clearTimeout(timeout);
+                if (pending === job)
+                    pending = undefined;
+            }
+        });
+        return job.promise;
+    }
+    function styleChanged() {
+        if (stopped)
+            return;
+        const current = state();
+        if (!current) {
+            pending?.controller.abort();
+            observedSource = undefined;
+            observedSignature = "";
+            return;
+        }
+        if (current.source !== observedSource || current.signature !== observedSignature)
+            void refresh();
+    }
+    function tileError(event) {
+        const error = event?.error;
+        if (stopped || !(error?.status === 410 || /^tile 410(?:\s|$)/.test(error?.message ?? "")))
+            return;
+        if (event.sourceId && event.sourceId !== "navdata")
+            return;
+        const current = state();
+        if (!current)
+            return;
+        const failed = typeof error.url === "string" ? tileIdentity(error.url) : undefined;
+        if (failed ? failed.prefix !== current.prefix || failed.period !== current.period : event.sourceId !== "navdata")
+            return;
+        const now = Date.now();
+        if (now - lastErrorRefresh < 2000)
+            return;
+        lastErrorRefresh = now;
+        void refresh();
+    }
+    const timer = setInterval(() => { void refresh(); }, intervalMs);
+    function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+        pending?.controller.abort();
+        map.off("remove", stop);
+        map.off("error", tileError);
+        map.off("styledata", styleChanged);
+    }
+    map.on("remove", stop);
+    map.on("error", tileError);
+    map.on("styledata", styleChanged);
+    void refresh();
+    return { refresh, stop };
+}
+
 // ICAO aviation chart layer styles — token-driven multi-theme.
 //
 // 单一 buildLayers(T)：图层结构只写一份（以 light 为准）；凡随主题变化的值
@@ -10267,10 +10532,10 @@ function buildLayers(themeId = 'light') {
     {
       id: 'airspace_label_center_layer', type: 'symbol', source: sourceId, 'source-layer': 'fir-centroid',
       minzoom: 3,
-      "maxzoom": 6,
+      maxzoom: 7,
       layout: {
         'text-field': '{CODE_ID}',
-        'text-font': frutigerBold,
+        'text-font': ['Frutiger Regular'],
         'symbol-placement': 'point',
         'text-max-width': 8,
         'symbol-sort-key': ['*', -1, ['get', 'SIZE']],
@@ -10287,11 +10552,11 @@ function buildLayers(themeId = 'light') {
             ["linear"],
             ["sqrt", ["get", "SIZE"]],
             100, 9,
-            316, 11,
-            707, 13,
-            1000, 14,
-            1414, 16,
-            2236, 18
+            316, 10,
+            707, 12,
+            1000, 13,
+            1414, 14,
+            2236, 16
           ],
 
           // Z4：区域视角
@@ -10300,12 +10565,12 @@ function buildLayers(themeId = 'light') {
             "interpolate",
             ["linear"],
             ["sqrt", ["get", "SIZE"]],
-            100, 10,
-            316, 12,
-            707, 14,
-            1000, 16,
-            1414, 18,
-            2236, 20
+            100, 9,
+            316, 11,
+            707, 13,
+            1000, 15,
+            1414, 16,
+            2236, 18
           ],
 
           // Z6：FIR 最后显示层级
@@ -10314,19 +10579,19 @@ function buildLayers(themeId = 'light') {
             "interpolate",
             ["linear"],
             ["sqrt", ["get", "SIZE"]],
-            100, 11,
-            316, 13,
-            707, 15,
-            1000, 17,
-            1414, 19,
-            2236, 21
+            100, 10,
+            316, 12,
+            707, 13,
+            1000, 15,
+            1414, 16,
+            2236, 18
           ]
-        ]
+        ],
       },
       paint: {
         'text-color': T.airspaceStroke,
         ...T.centerHalo,
-        'text-opacity': ['interpolate', ['linear'], ['zoom'], 3, 0.85, 8, 0.7, 12, 0.5],
+        'text-opacity': ['interpolate', ['linear'], ['zoom'], 3, 0.5, 8, 0.5, 12, 0.5],
       },
     },
     {
@@ -10635,7 +10900,8 @@ function buildLayers(themeId = 'light') {
           true                                                 // zoom >5，全部显示
         ],
       layout: {
-        "icon-image": ["case", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MIL"], "airport-mil", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MILEXT"], "airport-milext", "airport-civ"],
+        "icon-image": ["case", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MIL"], "airport-milext-circle", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MILEXT"], "airport-mil-circle", "airport-civ-cirlce"],
+        // "icon-image": ["case", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MIL"], "airport-mil", ["==", ["get", "CODE_TYPE_MIL_OPS"], "MILEXT"], "airport-milext", "airport-civ"],
         "symbol-z-order": "viewport-y",
         "text-letter-spacing": 0.05,
         "icon-pitch-alignment": "map",
@@ -11014,7 +11280,7 @@ function buildLayers(themeId = 'light') {
         'text-max-width': 20,
         'text-allow-overlap': false,
         'text-size': ['interpolate', ['exponential', 2], ['zoom'], 5, 6, 7, 10.5],
-        'text-radial-offset': 1,
+        'text-radial-offset': 1.5,
         'text-justify': 'auto',
         'text-variable-anchor': ['bottom', 'right', 'left', 'top', 'bottom-right', 'bottom-left', 'top-right', 'top-left'],
         'text-font': ['Fira Code SemiBold'],
@@ -11258,6 +11524,8 @@ class MapSDK {
                 this.initializeAviationLayers();
                 this._stopAMMVersioning?.();
                 this._stopAMMVersioning = watchAMMVersion(this.map);
+                this._navDataVersioning?.stop();
+                this._navDataVersioning = watchNavDataVersion(this.map);
             }
             this.map.fire("loadComplete", { notam: this.notam, adsb: this.adsb });
             this.map.fire("aviation:ready", { notam: this.notam, adsb: this.adsb });
@@ -11681,6 +11949,7 @@ class MapSDK {
         const navdata = this.map?.getSource("navdata");
         if (navdata?.setTiles) {
             navdata.setTiles([navdataTilesUrl(this._chartApiUrl, period, this._apiVersion, !!this._tileCipher)]);
+            void this._navDataVersioning?.refresh();
         }
         if (from !== undefined && from !== period) {
             this.map?.fire("periodchange", { from, to: period });
@@ -11853,6 +12122,8 @@ class MapSDK {
             return;
         this._stopAMMVersioning?.();
         this._stopAMMVersioning = undefined;
+        this._navDataVersioning?.stop();
+        this._navDataVersioning = undefined;
         this.globalConfig.setMapReinitCallback(null);
         this.pluginManager.destroy();
         this.performanceManager.destroy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aviation-chart",
-  "version": "2.0.34",
+  "version": "2.0.36",
   "description": "KunYu aviation map SDK",
   "main": "dist/nav-sdk.esm.js",
   "module": "dist/nav-sdk.esm.js",
@@ -68,7 +68,7 @@
     "vite": "^4.0.0"
   },
   "dependencies": {
-    "@geoman-io/maplibre-geoman-free": "^0.4.8",
+    "@geoman-io/maplibre-geoman-free": "0.4.8",
     "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^2.2.0",
     "@turf/circle": "^6.5.0",