@gemeentenijmegen/webapp 1.1.9 → 1.1.11

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -247,12 +247,24 @@ var Schema = class {
 };
 
 // src/submodules/schema/schemas/ListSchema.ts
-var ListSchema = class extends Schema {
+var ListSchema = class _ListSchema extends Schema {
   constructor(name, traits, valueSchema) {
     super(name, traits);
     this.name = name;
     this.traits = traits;
     this.valueSchema = valueSchema;
+    this.symbol = _ListSchema.symbol;
+  }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::ListSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _ListSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const list2 = lhs;
+      return list2.symbol === _ListSchema.symbol;
+    }
+    return isPrototype;
   }
 };
 function list(namespace, name, traits = {}, valueSchema) {
@@ -266,13 +278,25 @@ function list(namespace, name, traits = {}, valueSchema) {
 }
 
 // src/submodules/schema/schemas/MapSchema.ts
-var MapSchema = class extends Schema {
+var MapSchema = class _MapSchema extends Schema {
   constructor(name, traits, keySchema, valueSchema) {
     super(name, traits);
     this.name = name;
     this.traits = traits;
     this.keySchema = keySchema;
     this.valueSchema = valueSchema;
+    this.symbol = _MapSchema.symbol;
+  }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::MapSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _MapSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const map2 = lhs;
+      return map2.symbol === _MapSchema.symbol;
+    }
+    return isPrototype;
   }
 };
 function map(namespace, name, traits = {}, keySchema, valueSchema) {
@@ -303,18 +327,30 @@ function op(namespace, name, traits = {}, input, output) {
 }
 
 // src/submodules/schema/schemas/StructureSchema.ts
-var StructureSchema = class extends Schema {
+var StructureSchema = class _StructureSchema extends Schema {
   constructor(name, traits, memberNames, memberList) {
     super(name, traits);
     this.name = name;
     this.traits = traits;
     this.memberNames = memberNames;
     this.memberList = memberList;
+    this.symbol = _StructureSchema.symbol;
     this.members = {};
     for (let i = 0; i < memberNames.length; ++i) {
       this.members[memberNames[i]] = Array.isArray(memberList[i]) ? memberList[i] : [memberList[i], 0];
     }
   }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _StructureSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const struct2 = lhs;
+      return struct2.symbol === _StructureSchema.symbol;
+    }
+    return isPrototype;
+  }
 };
 function struct(namespace, name, traits, memberNames, memberList) {
   const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
@@ -323,7 +359,7 @@ function struct(namespace, name, traits, memberNames, memberList) {
 }
 
 // src/submodules/schema/schemas/ErrorSchema.ts
-var ErrorSchema = class extends StructureSchema {
+var ErrorSchema = class _ErrorSchema extends StructureSchema {
   constructor(name, traits, memberNames, memberList, ctor) {
     super(name, traits, memberNames, memberList);
     this.name = name;
@@ -331,6 +367,18 @@ var ErrorSchema = class extends StructureSchema {
     this.memberNames = memberNames;
     this.memberList = memberList;
     this.ctor = ctor;
+    this.symbol = _ErrorSchema.symbol;
+  }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _ErrorSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const err = lhs;
+      return err.symbol === _ErrorSchema.symbol;
+    }
+    return isPrototype;
   }
 };
 function error(namespace, name, traits = {}, memberNames, memberList, ctor) {
@@ -372,12 +420,24 @@ var SCHEMA = {
 };
 
 // src/submodules/schema/schemas/SimpleSchema.ts
-var SimpleSchema = class extends Schema {
+var SimpleSchema = class _SimpleSchema extends Schema {
   constructor(name, schemaRef, traits) {
     super(name, traits);
     this.name = name;
     this.schemaRef = schemaRef;
     this.traits = traits;
+    this.symbol = _SimpleSchema.symbol;
+  }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _SimpleSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const sim2 = lhs;
+      return sim2.symbol === _SimpleSchema.symbol;
+    }
+    return isPrototype;
   }
 };
 function sim(namespace, name, schemaRef, traits) {
@@ -395,6 +455,7 @@ var NormalizedSchema = class _NormalizedSchema {
   constructor(ref, memberName) {
     this.ref = ref;
     this.memberName = memberName;
+    this.symbol = _NormalizedSchema.symbol;
     const traitStack = [];
     let _ref = ref;
     let schema = ref;
@@ -434,10 +495,23 @@ var NormalizedSchema = class _NormalizedSchema {
     this.name = (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
     if (this._isMemberSchema && !memberName) {
       throw new Error(
-        `@smithy/core/schema - NormalizedSchema member schema ${this.getName(true)} must initialize with memberName argument.`
+        `@smithy/core/schema - NormalizedSchema member schema ${this.getName(
+          true
+        )} must initialize with memberName argument.`
       );
     }
   }
+  static {
+    this.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = _NormalizedSchema.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const ns = lhs;
+      return ns.symbol === _NormalizedSchema.symbol;
+    }
+    return isPrototype;
+  }
   /**
    * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
    */
@@ -584,6 +658,18 @@ var NormalizedSchema = class _NormalizedSchema {
     }
     return this.getSchema() === SCHEMA.STREAMING_BLOB;
   }
+  /**
+   * This is a shortcut to avoid calling `getMergedTraits().idempotencyToken` on every string.
+   * @returns whether the schema has the idempotencyToken trait.
+   */
+  isIdempotencyToken() {
+    if (typeof this.traits === "number") {
+      return (this.traits & 4) === 4;
+    } else if (typeof this.traits === "object") {
+      return !!this.traits.idempotencyToken;
+    }
+    return false;
+  }
   /**
    * @returns own traits merged with member traits, where member traits of the same trait key take priority.
    * This method is cached.

package/node_modules/@smithy/core/dist-cjs/submodules/serde/index.js

@@ -35,6 +35,7 @@ __export(serde_exports, {
   expectShort: () => expectShort,
   expectString: () => expectString,
   expectUnion: () => expectUnion,
+  generateIdempotencyToken: () => import_uuid.v4,
   handleFloat: () => handleFloat,
   limitedParseDouble: () => limitedParseDouble,
   limitedParseFloat: () => limitedParseFloat,
@@ -61,57 +62,7 @@ __export(serde_exports, {
 module.exports = __toCommonJS(serde_exports);
 
 // src/submodules/serde/copyDocumentWithTransform.ts
-var import_schema = require("@smithy/core/schema");
-var copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => {
-  const ns = import_schema.NormalizedSchema.of(schemaRef);
-  switch (typeof source) {
-    case "undefined":
-    case "boolean":
-    case "number":
-    case "string":
-    case "bigint":
-    case "symbol":
-      return transform(source, ns);
-    case "function":
-    case "object":
-      if (source === null) {
-        return transform(null, ns);
-      }
-      if (Array.isArray(source)) {
-        const newArray = new Array(source.length);
-        let i = 0;
-        for (const item of source) {
-          newArray[i++] = copyDocumentWithTransform(item, ns.getValueSchema(), transform);
-        }
-        return transform(newArray, ns);
-      }
-      if ("byteLength" in source) {
-        const newBytes = new Uint8Array(source.byteLength);
-        newBytes.set(source, 0);
-        return transform(newBytes, ns);
-      }
-      if (source instanceof Date) {
-        return transform(source, ns);
-      }
-      const newObject = {};
-      if (ns.isMapSchema()) {
-        for (const key of Object.keys(source)) {
-          newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
-        }
-      } else if (ns.isStructSchema()) {
-        for (const [key, memberSchema] of ns.structIterator()) {
-          newObject[key] = copyDocumentWithTransform(source[key], memberSchema, transform);
-        }
-      } else if (ns.isDocumentSchema()) {
-        for (const key of Object.keys(source)) {
-          newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
-        }
-      }
-      return transform(newObject, ns);
-    default:
-      return transform(source, ns);
-  }
-};
+var copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source;
 
 // src/submodules/serde/parse-utils.ts
 var parseBoolean = (value) => {
@@ -566,6 +517,9 @@ var stripLeadingZeroes = (value) => {
   return value.slice(idx);
 };
 
+// src/submodules/serde/generateIdempotencyToken.ts
+var import_uuid = require("uuid");
+
 // src/submodules/serde/lazy-json.ts
 var LazyJsonString = function LazyJsonString2(val) {
   const str = Object.assign(new String(val), {
@@ -667,14 +621,50 @@ var splitHeader = (value) => {
 };
 
 // src/submodules/serde/value/NumericValue.ts
-var NumericValue = class {
+var NumericValue = class _NumericValue {
   constructor(string, type) {
     this.string = string;
     this.type = type;
+    let dot = 0;
+    for (let i = 0; i < string.length; ++i) {
+      const char = string.charCodeAt(i);
+      if (i === 0 && char === 45) {
+        continue;
+      }
+      if (char === 46) {
+        if (dot) {
+          throw new Error("@smithy/core/serde - NumericValue must contain at most one decimal point.");
+        }
+        dot = 1;
+        continue;
+      }
+      if (char < 48 || char > 57) {
+        throw new Error(
+          `@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`
+        );
+      }
+    }
+  }
+  toString() {
+    return this.string;
+  }
+  static [Symbol.hasInstance](object) {
+    if (!object || typeof object !== "object") {
+      return false;
+    }
+    const _nv = object;
+    const prototypeMatch = _NumericValue.prototype.isPrototypeOf(object.constructor?.prototype);
+    if (prototypeMatch) {
+      return prototypeMatch;
+    }
+    if (typeof _nv.string === "string" && typeof _nv.type === "string" && _nv.constructor?.name === "NumericValue") {
+      return true;
+    }
+    return prototypeMatch;
   }
 };
-function nv(string) {
-  return new NumericValue(string, "bigDecimal");
+function nv(input) {
+  return new NumericValue(String(input), "bigDecimal");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -694,6 +684,7 @@ function nv(string) {
   expectShort,
   expectString,
   expectUnion,
+  generateIdempotencyToken,
   handleFloat,
   limitedParseDouble,
   limitedParseFloat,

package/node_modules/@smithy/core/dist-es/submodules/cbor/CborCodec.js

@@ -1,5 +1,6 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { copyDocumentWithTransform, parseEpochTimestamp } from "@smithy/core/serde";
+import { generateIdempotencyToken, parseEpochTimestamp } from "@smithy/core/serde";
+import { fromBase64 } from "@smithy/util-base64";
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
 export class CborCodec {
@@ -22,36 +23,71 @@ export class CborShapeSerializer {
         this.serdeContext = serdeContext;
     }
     write(schema, value) {
-        this.value = copyDocumentWithTransform(value, schema, (_, schemaRef) => {
-            if (_ instanceof Date) {
-                return dateToTag(_);
-            }
-            if (_ instanceof Uint8Array) {
-                return _;
-            }
-            const ns = NormalizedSchema.of(schemaRef);
-            const sparse = !!ns.getMergedTraits().sparse;
-            if (ns.isListSchema() && Array.isArray(_)) {
-                if (!sparse) {
-                    return _.filter((item) => item != null);
+        this.value = this.serialize(schema, value);
+    }
+    serialize(schema, source) {
+        const ns = NormalizedSchema.of(schema);
+        if (source == null) {
+            if (ns.isIdempotencyToken()) {
+                return generateIdempotencyToken();
+            }
+            return source;
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof source === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
+            }
+            return source;
+        }
+        if (ns.isTimestampSchema()) {
+            if (typeof source === "number" || typeof source === "bigint") {
+                return dateToTag(new Date((Number(source) / 1000) | 0));
+            }
+            return dateToTag(source);
+        }
+        if (typeof source === "function" || typeof source === "object") {
+            const sourceObject = source;
+            if (ns.isListSchema() && Array.isArray(sourceObject)) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                const newArray = [];
+                let i = 0;
+                for (const item of sourceObject) {
+                    const value = this.serialize(ns.getValueSchema(), item);
+                    if (value != null || sparse) {
+                        newArray[i++] = value;
+                    }
+                }
+                return newArray;
+            }
+            if (sourceObject instanceof Date) {
+                return dateToTag(sourceObject);
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                for (const key of Object.keys(sourceObject)) {
+                    const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                    if (value != null || sparse) {
+                        newObject[key] = value;
+                    }
                 }
             }
-            else if (_ && typeof _ === "object") {
-                const members = ns.getMemberSchemas();
-                const isStruct = ns.isStructSchema();
-                if (!sparse || isStruct) {
-                    for (const [k, v] of Object.entries(_)) {
-                        const filteredOutByNonSparse = !sparse && v == null;
-                        const filteredOutByUnrecognizedMember = isStruct && !(k in members);
-                        if (filteredOutByNonSparse || filteredOutByUnrecognizedMember) {
-                            delete _[k];
-                        }
+            else if (ns.isStructSchema()) {
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    const value = this.serialize(memberSchema, sourceObject[key]);
+                    if (value != null) {
+                        newObject[key] = value;
                     }
-                    return _;
                 }
             }
-            return _;
-        });
+            else if (ns.isDocumentSchema()) {
+                for (const key of Object.keys(sourceObject)) {
+                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                }
+            }
+            return newObject;
+        }
+        return source;
     }
     flush() {
         const buffer = cbor.serialize(this.value);
@@ -69,14 +105,14 @@ export class CborShapeDeserializer {
     }
     readValue(_schema, value) {
         const ns = NormalizedSchema.of(_schema);
-        const schema = ns.getSchema();
-        if (typeof schema === "number") {
-            if (ns.isTimestampSchema()) {
-                return parseEpochTimestamp(value);
-            }
-            if (ns.isBlobSchema()) {
-                return value;
+        if (ns.isTimestampSchema() && typeof value === "number") {
+            return parseEpochTimestamp(value);
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof value === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
             }
+            return value;
         }
         if (typeof value === "undefined" ||
             typeof value === "boolean" ||
@@ -102,23 +138,23 @@ export class CborShapeDeserializer {
             if (ns.isListSchema()) {
                 const newArray = [];
                 const memberSchema = ns.getValueSchema();
-                const sparse = ns.isListSchema() && !!ns.getMergedTraits().sparse;
+                const sparse = !!ns.getMergedTraits().sparse;
                 for (const item of value) {
-                    newArray.push(this.readValue(memberSchema, item));
-                    if (!sparse && newArray[newArray.length - 1] == null) {
-                        newArray.pop();
+                    const itemValue = this.readValue(memberSchema, item);
+                    if (itemValue != null || sparse) {
+                        newArray.push(itemValue);
                     }
                 }
                 return newArray;
             }
             const newObject = {};
             if (ns.isMapSchema()) {
-                const sparse = ns.getMergedTraits().sparse;
+                const sparse = !!ns.getMergedTraits().sparse;
                 const targetSchema = ns.getValueSchema();
                 for (const key of Object.keys(value)) {
-                    newObject[key] = this.readValue(targetSchema, value[key]);
-                    if (newObject[key] == null && !sparse) {
-                        delete newObject[key];
+                    const itemValue = this.readValue(targetSchema, value[key]);
+                    if (itemValue != null || sparse) {
+                        newObject[key] = itemValue;
                     }
                 }
             }

package/node_modules/@smithy/core/dist-es/submodules/cbor/byte-printer.js

@@ -0,0 +1,3 @@
+export function printBytes(bytes) {
+    return [...bytes].map((n) => ("0".repeat(8) + n.toString(2)).slice(-8) + ` (${n})`);
+}

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-decode.js

@@ -1,3 +1,4 @@
+import { nv } from "@smithy/core/serde";
 import { toUtf8 } from "@smithy/util-utf8";
 import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, extendedOneByte, majorList, majorMap, majorNegativeInt64, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, minorIndefinite, specialFalse, specialNull, specialTrue, specialUndefined, tag, } from "./cbor-types";
 const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
@@ -72,10 +73,44 @@ export function decode(at, to) {
                 return castBigInt(negativeInt);
             }
             else {
-                const value = decode(at + offset, to);
-                const valueOffset = _offset;
-                _offset = offset + valueOffset;
-                return tag({ tag: castBigInt(unsignedInt), value });
+                if (minor === 2 || minor === 3) {
+                    const length = decodeCount(at + offset, to);
+                    let b = BigInt(0);
+                    const start = at + offset + _offset;
+                    for (let i = start; i < start + length; ++i) {
+                        b = (b << BigInt(8)) | BigInt(payload[i]);
+                    }
+                    _offset = offset + _offset + length;
+                    return minor === 3 ? -b - BigInt(1) : b;
+                }
+                else if (minor === 4) {
+                    const decimalFraction = decode(at + offset, to);
+                    const [exponent, mantissa] = decimalFraction;
+                    const normalizer = mantissa < 0 ? -1 : 1;
+                    const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
+                    let numericString;
+                    const sign = mantissa < 0 ? "-" : "";
+                    numericString =
+                        exponent === 0
+                            ? mantissaStr
+                            : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
+                    numericString = numericString.replace(/^0+/g, "");
+                    if (numericString === "") {
+                        numericString = "0";
+                    }
+                    if (numericString[0] === ".") {
+                        numericString = "0" + numericString;
+                    }
+                    numericString = sign + numericString;
+                    _offset = offset + _offset;
+                    return nv(numericString);
+                }
+                else {
+                    const value = decode(at + offset, to);
+                    const valueOffset = _offset;
+                    _offset = offset + valueOffset;
+                    return tag({ tag: castBigInt(unsignedInt), value });
+                }
             }
         case majorUtf8String:
         case majorMap:

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -1,6 +1,6 @@
+import { NumericValue } from "@smithy/core/serde";
 import { fromUtf8 } from "@smithy/util-utf8";
-import { extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
-import { alloc } from "./cbor-types";
+import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
 const USE_BUFFER = typeof Buffer !== "undefined";
 const initialSize = 2048;
 let data = alloc(initialSize);
@@ -134,11 +134,31 @@ export function encode(_input) {
                 dataView.setUint32(cursor, n);
                 cursor += 4;
             }
-            else {
+            else if (value < BigInt("18446744073709551616")) {
                 data[cursor++] = (major << 5) | extendedFloat64;
                 dataView.setBigUint64(cursor, value);
                 cursor += 8;
             }
+            else {
+                const binaryBigInt = value.toString(2);
+                const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
+                let b = value;
+                let i = 0;
+                while (bigIntBytes.byteLength - ++i >= 0) {
+                    bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
+                    b >>= BigInt(8);
+                }
+                ensureSpace(bigIntBytes.byteLength * 2);
+                data[cursor++] = nonNegative ? 194 : 195;
+                if (USE_BUFFER) {
+                    encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
+                }
+                else {
+                    encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
+                }
+                data.set(bigIntBytes, cursor);
+                cursor += bigIntBytes.byteLength;
+            }
             continue;
         }
         else if (input === null) {
@@ -167,6 +187,16 @@ export function encode(_input) {
             continue;
         }
         else if (typeof input === "object") {
+            if (input instanceof NumericValue) {
+                const decimalIndex = input.string.indexOf(".");
+                const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
+                const mantissa = BigInt(input.string.replace(".", ""));
+                data[cursor++] = 196;
+                encodeStack.push(mantissa);
+                encodeStack.push(exponent);
+                encodeHeader(majorList, 2);
+                continue;
+            }
             if (input[tagSymbol]) {
                 if ("tag" in input && "value" in input) {
                     encodeStack.push(input.value);