@carbonenginejs/runtime-resource 0.12.0 → 0.12.1

package/dist/format/carbonEffect/carbonDescriptionFromPortable.js

@@ -0,0 +1,372 @@
+import { CjsFormatWriteError } from '../CjsFormatError.js';
+import { compareUtf8 } from '../compareUtf8.js';
+import { CARBON_ANNOTATION_TYPE } from './carbonEffectRecords.js';
+
+/**
+ * Maps a portable effect-body reflection onto Carbon v15 description records.
+ *
+ * This is the one mapping in the port with no oracle in CCP's files, because CCP
+ * never wrote one of our packages. Everything else the container does — arena
+ * policy, offset arithmetic, alias decisions, exhaustiveness — is Carbon records in
+ * and the same Carbon records out, checkable against shipped bytes. This direction
+ * is new: *our producer's data* into Carbon records.
+ *
+ * There is still an oracle, and it is strong. Our reflection is derived from a dx11
+ * file's own reflection through the HLSL reader, so the Carbon region we emit for an
+ * effect should be near-identical to the Carbon region of the file it came from —
+ * same constants at the same offsets, same texture and sampler slots, same
+ * registers, same render states. Every difference must be nameable. See
+ * `test/format/carbon-mapping.test.js`, which diffs the two field for field and
+ * fails on anything unexplained.
+ *
+ * Ordering is a mapping decision, not a copy. Carbon writes `textures`, `samplers`
+ * and `uavs` in ascending register index because they are `std::map`s
+ * (`EffectData.h:683-685`), render states likewise (`:719`), and it sorts annotation
+ * keys by `strcmp` before writing (`:613-616`, `:839-842`). The portable reflection
+ * preserves whatever order it was read in, so this module sorts explicitly rather
+ * than trusting that the input happened to arrive sorted.
+ */
+
+/**
+ * Wraps a string as the record codec's arena reference shape.
+ *
+ * @param {string} value Text value.
+ * @returns {{offset:number, value:string}} String reference.
+ */
+function str(value) {
+  return {
+    offset: 0,
+    value: String(value ?? "")
+  };
+}
+
+/**
+ * Wraps bytes as the record codec's sized blob reference.
+ *
+ * A zero-length blob keeps Carbon's null offset: the writer leaves the reference
+ * unset and the reader consumes the word without dereferencing it.
+ *
+ * @param {Uint8Array} bytes Blob bytes.
+ * @param {number} [declaredSize] Size to declare, when it is tracked separately.
+ * @returns {{size:number, offset:number, bytes:Uint8Array}} Blob reference.
+ */
+function blob(bytes, declaredSize) {
+  const owned = bytes instanceof Uint8Array ? bytes : new Uint8Array(0);
+  const size = declaredSize ?? owned.byteLength;
+  return {
+    size,
+    offset: size === 0 ? 0xffffffff : 0,
+    bytes: owned
+  };
+}
+const rawFloatBuffer = new DataView(new ArrayBuffer(4));
+
+/**
+ * Reinterprets a portable `*Raw` field's `u32` bit pattern as the float it encodes.
+ *
+ * The portable reflection stores sampler LOD and border-colour values as raw bits —
+ * `mipLODBiasRaw`, `minLODRaw`, `maxLODRaw`, `borderColorRaw` — precisely so that a
+ * value like `-FLT_MAX` survives JSON without going through a decimal round trip.
+ * Carbon's records store them as `float` (`EffectData.h:379,387-388`), so the bits
+ * have to be reinterpreted rather than assigned. Assigning the `u32` straight across
+ * writes `4286578687.0` where the file says `-3.4028235e38`, which every structural
+ * check in the container would accept.
+ *
+ * @param {number} bits Raw 32-bit pattern.
+ * @returns {number} The float those bits encode.
+ */
+function floatFromRaw(bits) {
+  if (!Number.isFinite(bits)) return 0;
+  rawFloatBuffer.setUint32(0, bits >>> 0, true);
+  return rawFloatBuffer.getFloat32(0, true);
+}
+
+/**
+ * Encodes a portable annotation's `u32` value as Carbon's four raw bytes.
+ *
+ * Carbon writes the value through the `float` member of a `{float,int32_t}` union
+ * and reads it back through a different union (`EffectData.h:582-593`,
+ * `Tr2EffectDescription.cpp:129-132`), so the bytes are the only faithful
+ * representation and no numeric conversion may happen here.
+ *
+ * @param {number} rawValue Portable annotation value.
+ * @returns {Uint8Array} Four little-endian bytes.
+ */
+function annotationBytes(rawValue) {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, rawValue >>> 0, true);
+  return bytes;
+}
+
+/**
+ * Maps one annotation list, in Carbon's `strcmp` key order.
+ *
+ * @param {object[]} annotations Portable annotations.
+ * @returns {object[]} Annotation records.
+ */
+function mapAnnotations(annotations) {
+  return (annotations ?? []).map(annotation => annotation.type === CARBON_ANNOTATION_TYPE.STRING ? {
+    name: str(annotation.name),
+    type: annotation.type,
+    stringValue: str(annotation.stringValue),
+    rawValue: null
+  } : {
+    name: str(annotation.name),
+    type: annotation.type,
+    stringValue: null,
+    rawValue: annotationBytes(annotation.rawValue)
+  }).sort((left, right) => compareUtf8(left.name.value, right.name.value));
+}
+
+/**
+ * Maps a portable sampler descriptor onto Carbon's sampler record.
+ *
+ * @param {object} entry Portable sampler entry.
+ * @returns {object} Sampler record.
+ */
+function mapSampler(entry) {
+  const descriptor = entry.descriptor ?? {};
+  return {
+    registerIndex: entry.registerIndex,
+    // Carbon nulls a sampler's name when it is not dynamic
+    // (`Tr2EffectDescription.cpp:430-433`), so an absent name round-trips as
+    // the empty string rather than being dropped.
+    name: str(entry.name ?? ""),
+    comparison: descriptor.comparison ? 1 : 0,
+    minFilter: descriptor.minFilter,
+    magFilter: descriptor.magFilter,
+    mipFilter: descriptor.mipFilter,
+    addressU: descriptor.addressU,
+    addressV: descriptor.addressV,
+    addressW: descriptor.addressW,
+    mipLODBias: floatFromRaw(descriptor.mipLODBiasRaw),
+    maxAnisotropy: descriptor.maxAnisotropy,
+    comparisonFunc: descriptor.comparisonFunc,
+    // On one line deliberately: the raw-field guard requires the
+    // reinterpretation to be visible on the same line as the raw access.
+    borderColor: (descriptor.borderColorRaw ?? [0, 0, 0, 0]).slice(0, 4).map(floatFromRaw),
+    minLOD: floatFromRaw(descriptor.minLODRaw),
+    maxLOD: floatFromRaw(descriptor.maxLODRaw),
+    isDynamic: entry.isDynamic ? 1 : 0
+  };
+}
+
+/**
+ * Maps a portable static sampler onto Carbon's static-sampler record.
+ *
+ * Border colour is a one-byte enum here, unlike the four floats on a dynamic
+ * sampler (`EffectData.h:565` versus `:453`).
+ *
+ * @param {object} entry Portable static sampler entry.
+ * @returns {object} Static sampler record.
+ */
+function mapStaticSampler(entry) {
+  const descriptor = entry.descriptor ?? {};
+  return {
+    registerIndex: entry.registerIndex,
+    registerSpace: entry.registerSpace,
+    comparison: descriptor.comparison ? 1 : 0,
+    minFilter: descriptor.minFilter,
+    magFilter: descriptor.magFilter,
+    mipFilter: descriptor.mipFilter,
+    addressU: descriptor.addressU,
+    addressV: descriptor.addressV,
+    addressW: descriptor.addressW,
+    mipLODBias: floatFromRaw(descriptor.mipLODBiasRaw),
+    maxAnisotropy: descriptor.maxAnisotropy,
+    comparisonFunc: descriptor.comparisonFunc,
+    borderColor: descriptor.borderColor,
+    minLOD: floatFromRaw(descriptor.minLODRaw),
+    maxLOD: floatFromRaw(descriptor.maxLODRaw)
+  };
+}
+
+/**
+ * Maps a portable resource entry onto Carbon's texture record.
+ *
+ * @param {object} entry Portable resource entry.
+ * @returns {object} Texture record.
+ */
+function mapTexture(entry) {
+  return {
+    registerIndex: entry.registerIndex,
+    name: str(entry.name),
+    type: entry.type,
+    count: entry.arrayElements,
+    isSRGB: entry.isSRGB ? 1 : 0,
+    isAutoregister: entry.isAutoregister ? 1 : 0
+  };
+}
+
+/**
+ * Maps a portable resource entry onto Carbon's UAV record.
+ *
+ * A UAV record is one byte shorter than a texture record: it carries no `isSRGB`
+ * (`EffectData.h:345-352`, `Tr2EffectDescription.cpp:450`).
+ *
+ * @param {object} entry Portable resource entry.
+ * @returns {object} UAV record.
+ */
+function mapUav(entry) {
+  return {
+    registerIndex: entry.registerIndex,
+    name: str(entry.name),
+    type: entry.type,
+    count: entry.arrayElements,
+    isAutoregister: entry.isAutoregister ? 1 : 0
+  };
+}
+
+/**
+ * Maps a portable input onto Carbon's `StageData` block.
+ *
+ * @param {object} input Portable input.
+ * @returns {object} Stage data record.
+ */
+function mapStageData(input) {
+  const signature = input?.signature ?? {};
+  const byRegister = (left, right) => left.registerIndex - right.registerIndex;
+  return {
+    registers: (signature.registers ?? []).map(entry => {
+      // Carbon stores one field that its reader calls `arrayCount` and its
+      // writer calls `registerCount` (`EffectData.h:495` / `Tr2ShaderAL.h:100`).
+      // The portable reflection carries both names; they must agree, or the
+      // collapse to one wire field would silently pick a side.
+      if (entry.arrayCount !== entry.registerCount) {
+        throw new CjsFormatWriteError("Portable register arrayCount and registerCount disagree; Carbon stores one field", {
+          arrayCount: entry.arrayCount,
+          registerCount: entry.registerCount
+        });
+      }
+      return {
+        registerType: entry.registerType,
+        registerIndex: entry.registerIndex,
+        registerCount: entry.registerCount,
+        registerSpace: entry.registerSpace
+      };
+    }),
+    staticSamplers: (signature.staticSamplers ?? []).map(mapStaticSampler),
+    constants: (input?.constants ?? []).map(constant => ({
+      name: str(constant.name),
+      offset: constant.offset,
+      size: constant.size,
+      type: constant.type,
+      dimension: constant.dimension,
+      elements: constant.elements,
+      isSRGB: constant.isSRGB ? 1 : 0,
+      isAutoregister: constant.isAutoregister ? 1 : 0
+    })),
+    defaultValues: blob(input?.constantDefaults?.bytes, input?.constantDefaults?.declaredByteLength),
+    textures: (input?.resources ?? []).map(mapTexture).sort(byRegister),
+    samplers: (input?.samplers ?? []).map(mapSampler).sort(byRegister),
+    uavs: (input?.uavs ?? []).map(mapUav).sort(byRegister),
+    annotations: mapAnnotations(input?.annotations)
+  };
+}
+
+/**
+ * Maps one portable stage onto Carbon's `StageInput` record.
+ *
+ * @param {object} stage Portable stage.
+ * @param {object} context Mapping context carrying the program substitution.
+ * @returns {object} Stage record.
+ */
+function mapStage(stage, context) {
+  const signature = stage.input?.signature ?? {};
+  const program = stage.sourceProgram ?? {};
+  const threadGroupSize = signature.threadGroupSize ?? {};
+  const substituted = context.programFor ? context.programFor(stage, context) : null;
+  return {
+    type: stage.stageType,
+    // `shaderData` is the one field a backend replaces: the record layout is
+    // backend-invariant, so a WGSL or GLSL program occupies exactly the slot
+    // DXBC occupies in a shipped file. Absent a substitution the source
+    // program passes through, which is what re-emitting a dx11 file does.
+    shaderData: substituted ? blob(substituted.bytes, substituted.size) : blob(program.bytes, program.shaderSize),
+    threadGroupSize: [threadGroupSize.x ?? 0, threadGroupSize.y ?? 0, threadGroupSize.z ?? 0],
+    pipelineInputs: (signature.pipelineInputs ?? []).map(entry => ({
+      usage: entry.usage,
+      registerIndex: entry.registerIndex,
+      usageIndex: entry.usageIndex,
+      usedMask: entry.usedMask,
+      type: entry.type,
+      dimension: entry.dimension
+    })),
+    ...mapStageData(stage.input)
+  };
+}
+
+/**
+ * Maps one portable library onto Carbon's raytracing library record.
+ *
+ * @param {object} library Portable library.
+ * @returns {object} Library record.
+ */
+function mapLibrary(library) {
+  const program = library.sourceProgram ?? {};
+  return {
+    payloadSize: library.payloadSize >>> 0,
+    shaderData: blob(program.bytes, program.shaderSize),
+    exports: (library.exports ?? []).map(entry => ({
+      type: entry.type,
+      name: str(entry.name)
+    })),
+    hitGroupName: str(library.hitGroupName),
+    globalInputs: mapStageData(library.globalInput),
+    localInputs: mapStageData(library.localInput)
+  };
+}
+
+/**
+ * Maps a portable effect-body reflection onto a Carbon v15 description record tree.
+ *
+ * Two optional hooks make the same mapping serve a backend emit. Both are pure
+ * functions of the record being mapped, so the mapping stays a mapping: nothing
+ * about the Carbon region changes shape when a backend supplies them, only which
+ * bytes land in `shaderData` and whether the one optional trailing block per pass
+ * carries anything.
+ *
+ * @param {object} reflection Portable effect-body reflection.
+ * @param {object} [hooks] Backend substitution hooks.
+ * @param {Function} [hooks.programFor] Returns `{bytes, size}` for one stage.
+ * @param {Function} [hooks.backendBlockFor] Returns block bytes for one pass.
+ * @returns {object} Description record tree, ready for `writeEffectDescription`.
+ */
+function carbonDescriptionFromPortable(reflection, hooks = {}) {
+  const effect = reflection?.effect;
+  if (!effect) {
+    throw new CjsFormatWriteError("Portable reflection has no effect", {});
+  }
+  return {
+    techniques: (effect.techniques ?? []).map(technique => ({
+      name: str(technique.name),
+      passes: (technique.passes ?? []).map((pass, passIndex) => {
+        const context = {
+          techniqueName: String(technique.name ?? ""),
+          passIndex,
+          passKey: `${technique.name}.pass${passIndex}`,
+          programFor: hooks.programFor
+        };
+        const block = hooks.backendBlockFor ? hooks.backendBlockFor(context, pass) : null;
+        return {
+          stages: (pass.stages ?? []).map(stage => mapStage(stage, context)),
+          renderStates: (pass.renderStates ?? []).map(entry => ({
+            state: entry.state >>> 0,
+            value: entry.value >>> 0
+          })).sort((left, right) => left.state - right.state),
+          ...(block ? {
+            backendBlock: blob(block)
+          } : {})
+        };
+      }),
+      libraries: (technique.libraries ?? []).map(mapLibrary)
+    })),
+    annotations: (effect.annotations ?? []).map(group => ({
+      name: str(group.parameterName),
+      annotations: mapAnnotations(group.annotations)
+    })).sort((left, right) => compareUtf8(left.name.value, right.name.value))
+  };
+}
+
+export { carbonDescriptionFromPortable };
+//# sourceMappingURL=carbonDescriptionFromPortable.js.map

package/dist/format/carbonEffect/carbonDescriptionFromPortable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"carbonDescriptionFromPortable.js","sources":["../../../../src/format/carbonEffect/carbonDescriptionFromPortable.js"],"sourcesContent":["import { CjsFormatWriteError } from \"../CjsFormatError.js\";\r\nimport { compareUtf8 } from \"../compareUtf8.js\";\r\nimport { CARBON_ANNOTATION_TYPE } from \"./carbonEffectRecords.js\";\r\n\r\n/**\r\n * Maps a portable effect-body reflection onto Carbon v15 description records.\r\n *\r\n * This is the one mapping in the port with no oracle in CCP's files, because CCP\r\n * never wrote one of our packages. Everything else the container does — arena\r\n * policy, offset arithmetic, alias decisions, exhaustiveness — is Carbon records in\r\n * and the same Carbon records out, checkable against shipped bytes. This direction\r\n * is new: *our producer's data* into Carbon records.\r\n *\r\n * There is still an oracle, and it is strong. Our reflection is derived from a dx11\r\n * file's own reflection through the HLSL reader, so the Carbon region we emit for an\r\n * effect should be near-identical to the Carbon region of the file it came from —\r\n * same constants at the same offsets, same texture and sampler slots, same\r\n * registers, same render states. Every difference must be nameable. See\r\n * `test/format/carbon-mapping.test.js`, which diffs the two field for field and\r\n * fails on anything unexplained.\r\n *\r\n * Ordering is a mapping decision, not a copy. Carbon writes `textures`, `samplers`\r\n * and `uavs` in ascending register index because they are `std::map`s\r\n * (`EffectData.h:683-685`), render states likewise (`:719`), and it sorts annotation\r\n * keys by `strcmp` before writing (`:613-616`, `:839-842`). The portable reflection\r\n * preserves whatever order it was read in, so this module sorts explicitly rather\r\n * than trusting that the input happened to arrive sorted.\r\n */\r\n\r\n/**\r\n * Wraps a string as the record codec's arena reference shape.\r\n *\r\n * @param {string} value Text value.\r\n * @returns {{offset:number, value:string}} String reference.\r\n */\r\nfunction str(value)\r\n{\r\n    return { offset: 0, value: String(value ?? \"\") };\r\n}\r\n\r\n/**\r\n * Wraps bytes as the record codec's sized blob reference.\r\n *\r\n * A zero-length blob keeps Carbon's null offset: the writer leaves the reference\r\n * unset and the reader consumes the word without dereferencing it.\r\n *\r\n * @param {Uint8Array} bytes Blob bytes.\r\n * @param {number} [declaredSize] Size to declare, when it is tracked separately.\r\n * @returns {{size:number, offset:number, bytes:Uint8Array}} Blob reference.\r\n */\r\nfunction blob(bytes, declaredSize)\r\n{\r\n    const owned = bytes instanceof Uint8Array ? bytes : new Uint8Array(0);\r\n    const size = declaredSize ?? owned.byteLength;\r\n    return { size, offset: size === 0 ? 0xffffffff : 0, bytes: owned };\r\n}\r\n\r\nconst rawFloatBuffer = new DataView(new ArrayBuffer(4));\r\n\r\n/**\r\n * Reinterprets a portable `*Raw` field's `u32` bit pattern as the float it encodes.\r\n *\r\n * The portable reflection stores sampler LOD and border-colour values as raw bits —\r\n * `mipLODBiasRaw`, `minLODRaw`, `maxLODRaw`, `borderColorRaw` — precisely so that a\r\n * value like `-FLT_MAX` survives JSON without going through a decimal round trip.\r\n * Carbon's records store them as `float` (`EffectData.h:379,387-388`), so the bits\r\n * have to be reinterpreted rather than assigned. Assigning the `u32` straight across\r\n * writes `4286578687.0` where the file says `-3.4028235e38`, which every structural\r\n * check in the container would accept.\r\n *\r\n * @param {number} bits Raw 32-bit pattern.\r\n * @returns {number} The float those bits encode.\r\n */\r\nfunction floatFromRaw(bits)\r\n{\r\n    if (!Number.isFinite(bits)) return 0;\r\n    rawFloatBuffer.setUint32(0, bits >>> 0, true);\r\n    return rawFloatBuffer.getFloat32(0, true);\r\n}\r\n\r\n/**\r\n * Encodes a portable annotation's `u32` value as Carbon's four raw bytes.\r\n *\r\n * Carbon writes the value through the `float` member of a `{float,int32_t}` union\r\n * and reads it back through a different union (`EffectData.h:582-593`,\r\n * `Tr2EffectDescription.cpp:129-132`), so the bytes are the only faithful\r\n * representation and no numeric conversion may happen here.\r\n *\r\n * @param {number} rawValue Portable annotation value.\r\n * @returns {Uint8Array} Four little-endian bytes.\r\n */\r\nfunction annotationBytes(rawValue)\r\n{\r\n    const bytes = new Uint8Array(4);\r\n    new DataView(bytes.buffer).setUint32(0, rawValue >>> 0, true);\r\n    return bytes;\r\n}\r\n\r\n/**\r\n * Maps one annotation list, in Carbon's `strcmp` key order.\r\n *\r\n * @param {object[]} annotations Portable annotations.\r\n * @returns {object[]} Annotation records.\r\n */\r\nfunction mapAnnotations(annotations)\r\n{\r\n    return (annotations ?? [])\r\n        .map((annotation) => (annotation.type === CARBON_ANNOTATION_TYPE.STRING\r\n            ? {\r\n                name: str(annotation.name),\r\n                type: annotation.type,\r\n                stringValue: str(annotation.stringValue),\r\n                rawValue: null\r\n            }\r\n            : {\r\n                name: str(annotation.name),\r\n                type: annotation.type,\r\n                stringValue: null,\r\n                rawValue: annotationBytes(annotation.rawValue)\r\n            }))\r\n        .sort((left, right) => compareUtf8(left.name.value, right.name.value));\r\n}\r\n\r\n/**\r\n * Maps a portable sampler descriptor onto Carbon's sampler record.\r\n *\r\n * @param {object} entry Portable sampler entry.\r\n * @returns {object} Sampler record.\r\n */\r\nfunction mapSampler(entry)\r\n{\r\n    const descriptor = entry.descriptor ?? {};\r\n    return {\r\n        registerIndex: entry.registerIndex,\r\n        // Carbon nulls a sampler's name when it is not dynamic\r\n        // (`Tr2EffectDescription.cpp:430-433`), so an absent name round-trips as\r\n        // the empty string rather than being dropped.\r\n        name: str(entry.name ?? \"\"),\r\n        comparison: descriptor.comparison ? 1 : 0,\r\n        minFilter: descriptor.minFilter,\r\n        magFilter: descriptor.magFilter,\r\n        mipFilter: descriptor.mipFilter,\r\n        addressU: descriptor.addressU,\r\n        addressV: descriptor.addressV,\r\n        addressW: descriptor.addressW,\r\n        mipLODBias: floatFromRaw(descriptor.mipLODBiasRaw),\r\n        maxAnisotropy: descriptor.maxAnisotropy,\r\n        comparisonFunc: descriptor.comparisonFunc,\r\n        // On one line deliberately: the raw-field guard requires the\r\n        // reinterpretation to be visible on the same line as the raw access.\r\n        borderColor: (descriptor.borderColorRaw ?? [ 0, 0, 0, 0 ]).slice(0, 4).map(floatFromRaw),\r\n        minLOD: floatFromRaw(descriptor.minLODRaw),\r\n        maxLOD: floatFromRaw(descriptor.maxLODRaw),\r\n        isDynamic: entry.isDynamic ? 1 : 0\r\n    };\r\n}\r\n\r\n/**\r\n * Maps a portable static sampler onto Carbon's static-sampler record.\r\n *\r\n * Border colour is a one-byte enum here, unlike the four floats on a dynamic\r\n * sampler (`EffectData.h:565` versus `:453`).\r\n *\r\n * @param {object} entry Portable static sampler entry.\r\n * @returns {object} Static sampler record.\r\n */\r\nfunction mapStaticSampler(entry)\r\n{\r\n    const descriptor = entry.descriptor ?? {};\r\n    return {\r\n        registerIndex: entry.registerIndex,\r\n        registerSpace: entry.registerSpace,\r\n        comparison: descriptor.comparison ? 1 : 0,\r\n        minFilter: descriptor.minFilter,\r\n        magFilter: descriptor.magFilter,\r\n        mipFilter: descriptor.mipFilter,\r\n        addressU: descriptor.addressU,\r\n        addressV: descriptor.addressV,\r\n        addressW: descriptor.addressW,\r\n        mipLODBias: floatFromRaw(descriptor.mipLODBiasRaw),\r\n        maxAnisotropy: descriptor.maxAnisotropy,\r\n        comparisonFunc: descriptor.comparisonFunc,\r\n        borderColor: descriptor.borderColor,\r\n        minLOD: floatFromRaw(descriptor.minLODRaw),\r\n        maxLOD: floatFromRaw(descriptor.maxLODRaw)\r\n    };\r\n}\r\n\r\n/**\r\n * Maps a portable resource entry onto Carbon's texture record.\r\n *\r\n * @param {object} entry Portable resource entry.\r\n * @returns {object} Texture record.\r\n */\r\nfunction mapTexture(entry)\r\n{\r\n    return {\r\n        registerIndex: entry.registerIndex,\r\n        name: str(entry.name),\r\n        type: entry.type,\r\n        count: entry.arrayElements,\r\n        isSRGB: entry.isSRGB ? 1 : 0,\r\n        isAutoregister: entry.isAutoregister ? 1 : 0\r\n    };\r\n}\r\n\r\n/**\r\n * Maps a portable resource entry onto Carbon's UAV record.\r\n *\r\n * A UAV record is one byte shorter than a texture record: it carries no `isSRGB`\r\n * (`EffectData.h:345-352`, `Tr2EffectDescription.cpp:450`).\r\n *\r\n * @param {object} entry Portable resource entry.\r\n * @returns {object} UAV record.\r\n */\r\nfunction mapUav(entry)\r\n{\r\n    return {\r\n        registerIndex: entry.registerIndex,\r\n        name: str(entry.name),\r\n        type: entry.type,\r\n        count: entry.arrayElements,\r\n        isAutoregister: entry.isAutoregister ? 1 : 0\r\n    };\r\n}\r\n\r\n/**\r\n * Maps a portable input onto Carbon's `StageData` block.\r\n *\r\n * @param {object} input Portable input.\r\n * @returns {object} Stage data record.\r\n */\r\nfunction mapStageData(input)\r\n{\r\n    const signature = input?.signature ?? {};\r\n    const byRegister = (left, right) => left.registerIndex - right.registerIndex;\r\n\r\n    return {\r\n        registers: (signature.registers ?? []).map((entry) =>\r\n        {\r\n            // Carbon stores one field that its reader calls `arrayCount` and its\r\n            // writer calls `registerCount` (`EffectData.h:495` / `Tr2ShaderAL.h:100`).\r\n            // The portable reflection carries both names; they must agree, or the\r\n            // collapse to one wire field would silently pick a side.\r\n            if (entry.arrayCount !== entry.registerCount)\r\n            {\r\n                throw new CjsFormatWriteError(\r\n                    \"Portable register arrayCount and registerCount disagree; Carbon stores one field\",\r\n                    { arrayCount: entry.arrayCount, registerCount: entry.registerCount }\r\n                );\r\n            }\r\n            return {\r\n                registerType: entry.registerType,\r\n                registerIndex: entry.registerIndex,\r\n                registerCount: entry.registerCount,\r\n                registerSpace: entry.registerSpace\r\n            };\r\n        }),\r\n        staticSamplers: (signature.staticSamplers ?? []).map(mapStaticSampler),\r\n        constants: (input?.constants ?? []).map((constant) => ({\r\n            name: str(constant.name),\r\n            offset: constant.offset,\r\n            size: constant.size,\r\n            type: constant.type,\r\n            dimension: constant.dimension,\r\n            elements: constant.elements,\r\n            isSRGB: constant.isSRGB ? 1 : 0,\r\n            isAutoregister: constant.isAutoregister ? 1 : 0\r\n        })),\r\n        defaultValues: blob(\r\n            input?.constantDefaults?.bytes,\r\n            input?.constantDefaults?.declaredByteLength\r\n        ),\r\n        textures: (input?.resources ?? []).map(mapTexture).sort(byRegister),\r\n        samplers: (input?.samplers ?? []).map(mapSampler).sort(byRegister),\r\n        uavs: (input?.uavs ?? []).map(mapUav).sort(byRegister),\r\n        annotations: mapAnnotations(input?.annotations)\r\n    };\r\n}\r\n\r\n/**\r\n * Maps one portable stage onto Carbon's `StageInput` record.\r\n *\r\n * @param {object} stage Portable stage.\r\n * @param {object} context Mapping context carrying the program substitution.\r\n * @returns {object} Stage record.\r\n */\r\nfunction mapStage(stage, context)\r\n{\r\n    const signature = stage.input?.signature ?? {};\r\n    const program = stage.sourceProgram ?? {};\r\n    const threadGroupSize = signature.threadGroupSize ?? {};\r\n    const substituted = context.programFor\r\n        ? context.programFor(stage, context)\r\n        : null;\r\n\r\n    return {\r\n        type: stage.stageType,\r\n        // `shaderData` is the one field a backend replaces: the record layout is\r\n        // backend-invariant, so a WGSL or GLSL program occupies exactly the slot\r\n        // DXBC occupies in a shipped file. Absent a substitution the source\r\n        // program passes through, which is what re-emitting a dx11 file does.\r\n        shaderData: substituted\r\n            ? blob(substituted.bytes, substituted.size)\r\n            : blob(program.bytes, program.shaderSize),\r\n        threadGroupSize: [\r\n            threadGroupSize.x ?? 0,\r\n            threadGroupSize.y ?? 0,\r\n            threadGroupSize.z ?? 0\r\n        ],\r\n        pipelineInputs: (signature.pipelineInputs ?? []).map((entry) => ({\r\n            usage: entry.usage,\r\n            registerIndex: entry.registerIndex,\r\n            usageIndex: entry.usageIndex,\r\n            usedMask: entry.usedMask,\r\n            type: entry.type,\r\n            dimension: entry.dimension\r\n        })),\r\n        ...mapStageData(stage.input)\r\n    };\r\n}\r\n\r\n/**\r\n * Maps one portable library onto Carbon's raytracing library record.\r\n *\r\n * @param {object} library Portable library.\r\n * @returns {object} Library record.\r\n */\r\nfunction mapLibrary(library)\r\n{\r\n    const program = library.sourceProgram ?? {};\r\n    return {\r\n        payloadSize: library.payloadSize >>> 0,\r\n        shaderData: blob(program.bytes, program.shaderSize),\r\n        exports: (library.exports ?? []).map((entry) => ({\r\n            type: entry.type,\r\n            name: str(entry.name)\r\n        })),\r\n        hitGroupName: str(library.hitGroupName),\r\n        globalInputs: mapStageData(library.globalInput),\r\n        localInputs: mapStageData(library.localInput)\r\n    };\r\n}\r\n\r\n/**\r\n * Maps a portable effect-body reflection onto a Carbon v15 description record tree.\r\n *\r\n * Two optional hooks make the same mapping serve a backend emit. Both are pure\r\n * functions of the record being mapped, so the mapping stays a mapping: nothing\r\n * about the Carbon region changes shape when a backend supplies them, only which\r\n * bytes land in `shaderData` and whether the one optional trailing block per pass\r\n * carries anything.\r\n *\r\n * @param {object} reflection Portable effect-body reflection.\r\n * @param {object} [hooks] Backend substitution hooks.\r\n * @param {Function} [hooks.programFor] Returns `{bytes, size}` for one stage.\r\n * @param {Function} [hooks.backendBlockFor] Returns block bytes for one pass.\r\n * @returns {object} Description record tree, ready for `writeEffectDescription`.\r\n */\r\nexport function carbonDescriptionFromPortable(reflection, hooks = {})\r\n{\r\n    const effect = reflection?.effect;\r\n    if (!effect)\r\n    {\r\n        throw new CjsFormatWriteError(\"Portable reflection has no effect\", {});\r\n    }\r\n\r\n    return {\r\n        techniques: (effect.techniques ?? []).map((technique) => ({\r\n            name: str(technique.name),\r\n            passes: (technique.passes ?? []).map((pass, passIndex) =>\r\n            {\r\n                const context = {\r\n                    techniqueName: String(technique.name ?? \"\"),\r\n                    passIndex,\r\n                    passKey: `${technique.name}.pass${passIndex}`,\r\n                    programFor: hooks.programFor\r\n                };\r\n                const block = hooks.backendBlockFor\r\n                    ? hooks.backendBlockFor(context, pass)\r\n                    : null;\r\n\r\n                return {\r\n                    stages: (pass.stages ?? []).map((stage) => mapStage(stage, context)),\r\n                    renderStates: (pass.renderStates ?? [])\r\n                        .map((entry) => ({ state: entry.state >>> 0, value: entry.value >>> 0 }))\r\n                        .sort((left, right) => left.state - right.state),\r\n                    ...(block ? { backendBlock: blob(block) } : {})\r\n                };\r\n            }),\r\n            libraries: (technique.libraries ?? []).map(mapLibrary)\r\n        })),\r\n        annotations: (effect.annotations ?? [])\r\n            .map((group) => ({\r\n                name: str(group.parameterName),\r\n                annotations: mapAnnotations(group.annotations)\r\n            }))\r\n            .sort((left, right) => compareUtf8(left.name.value, right.name.value))\r\n    };\r\n}\r\n\r\nexport default carbonDescriptionFromPortable;\r\n"],"names":["str","value","offset","String","blob","bytes","declaredSize","owned","Uint8Array","size","byteLength","rawFloatBuffer","DataView","ArrayBuffer","floatFromRaw","bits","Number","isFinite","setUint32","getFloat32","annotationBytes","rawValue","buffer","mapAnnotations","annotations","map","annotation","type","CARBON_ANNOTATION_TYPE","STRING","name","stringValue","sort","left","right","compareUtf8","mapSampler","entry","descriptor","registerIndex","comparison","minFilter","magFilter","mipFilter","addressU","addressV","addressW","mipLODBias","mipLODBiasRaw","maxAnisotropy","comparisonFunc","borderColor","borderColorRaw","slice","minLOD","minLODRaw","maxLOD","maxLODRaw","isDynamic","mapStaticSampler","registerSpace","mapTexture","count","arrayElements","isSRGB","isAutoregister","mapUav","mapStageData","input","signature","byRegister","registers","arrayCount","registerCount","CjsFormatWriteError","registerType","staticSamplers","constants","constant","dimension","elements","defaultValues","constantDefaults","declaredByteLength","textures","resources","samplers","uavs","mapStage","stage","context","program","sourceProgram","threadGroupSize","substituted","programFor","stageType","shaderData","shaderSize","x","y","z","pipelineInputs","usage","usageIndex","usedMask","mapLibrary","library","payloadSize","exports","hitGroupName","globalInputs","globalInput","localInputs","localInput","carbonDescriptionFromPortable","reflection","hooks","effect","techniques","technique","passes","pass","passIndex","techniqueName","passKey","block","backendBlockFor","stages","renderStates","state","backendBlock","libraries","group","parameterName"],"mappings":";;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,GAAGA,CAACC,KAAK,EAClB;EACI,OAAO;AAAEC,IAAAA,MAAM,EAAE,CAAC;AAAED,IAAAA,KAAK,EAAEE,MAAM,CAACF,KAAK,IAAI,EAAE;GAAG;AACpD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASG,IAAIA,CAACC,KAAK,EAAEC,YAAY,EACjC;AACI,EAAA,MAAMC,KAAK,GAAGF,KAAK,YAAYG,UAAU,GAAGH,KAAK,GAAG,IAAIG,UAAU,CAAC,CAAC,CAAC;AACrE,EAAA,MAAMC,IAAI,GAAGH,YAAY,IAAIC,KAAK,CAACG,UAAU;EAC7C,OAAO;IAAED,IAAI;AAAEP,IAAAA,MAAM,EAAEO,IAAI,KAAK,CAAC,GAAG,UAAU,GAAG,CAAC;AAAEJ,IAAAA,KAAK,EAAEE;GAAO;AACtE;AAEA,MAAMI,cAAc,GAAG,IAAIC,QAAQ,CAAC,IAAIC,WAAW,CAAC,CAAC,CAAC,CAAC;;AAEvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,YAAYA,CAACC,IAAI,EAC1B;EACI,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACF,IAAI,CAAC,EAAE,OAAO,CAAC;EACpCJ,cAAc,CAACO,SAAS,CAAC,CAAC,EAAEH,IAAI,KAAK,CAAC,EAAE,IAAI,CAAC;AAC7C,EAAA,OAAOJ,cAAc,CAACQ,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC;AAC7C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,eAAeA,CAACC,QAAQ,EACjC;AACI,EAAA,MAAMhB,KAAK,GAAG,IAAIG,UAAU,CAAC,CAAC,CAAC;AAC/B,EAAA,IAAII,QAAQ,CAACP,KAAK,CAACiB,MAAM,CAAC,CAACJ,SAAS,CAAC,CAAC,EAAEG,QAAQ,KAAK,CAAC,EAAE,IAAI,CAAC;AAC7D,EAAA,OAAOhB,KAAK;AAChB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASkB,cAAcA,CAACC,WAAW,EACnC;AACI,EAAA,OAAO,CAACA,WAAW,IAAI,EAAE,EACpBC,GAAG,CAAEC,UAAU,IAAMA,UAAU,CAACC,IAAI,KAAKC,sBAAsB,CAACC,MAAM,GACjE;AACEC,IAAAA,IAAI,EAAE9B,GAAG,CAAC0B,UAAU,CAACI,IAAI,CAAC;IAC1BH,IAAI,EAAED,UAAU,CAACC,IAAI;AACrBI,IAAAA,WAAW,EAAE/B,GAAG,CAAC0B,UAAU,CAACK,WAAW,CAAC;AACxCV,IAAAA,QAAQ,EAAE;AACd,GAAC,GACC;AACES,IAAAA,IAAI,EAAE9B,GAAG,CAAC0B,UAAU,CAACI,IAAI,CAAC;IAC1BH,IAAI,EAAED,UAAU,CAACC,IAAI;AACrBI,IAAAA,WAAW,EAAE,IAAI;AACjBV,IAAAA,QAAQ,EAAED,eAAe,CAACM,UAAU,CAACL,QAAQ;GAC/C,CAAC,CACNW,IAAI,CAAC,CAACC,IAAI,EAAEC,KAAK,KAAKC,WAAW,CAACF,IAAI,CAACH,IAAI,CAAC7B,KAAK,EAAEiC,KAAK,CAACJ,IAAI,CAAC7B,KAAK,CAAC,CAAC;AAC9E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASmC,UAAUA,CAACC,KAAK,EACzB;AACI,EAAA,MAAMC,UAAU,GAAGD,KAAK,CAACC,UAAU,IAAI,EAAE;EACzC,OAAO;IACHC,aAAa,EAAEF,KAAK,CAACE,aAAa;AAClC;AACA;AACA;IACAT,IAAI,EAAE9B,GAAG,CAACqC,KAAK,CAACP,IAAI,IAAI,EAAE,CAAC;AAC3BU,IAAAA,UAAU,EAAEF,UAAU,CAACE,UAAU,GAAG,CAAC,GAAG,CAAC;IACzCC,SAAS,EAAEH,UAAU,CAACG,SAAS;IAC/BC,SAAS,EAAEJ,UAAU,CAACI,SAAS;IAC/BC,SAAS,EAAEL,UAAU,CAACK,SAAS;IAC/BC,QAAQ,EAAEN,UAAU,CAACM,QAAQ;IAC7BC,QAAQ,EAAEP,UAAU,CAACO,QAAQ;IAC7BC,QAAQ,EAAER,UAAU,CAACQ,QAAQ;AAC7BC,IAAAA,UAAU,EAAEjC,YAAY,CAACwB,UAAU,CAACU,aAAa,CAAC;IAClDC,aAAa,EAAEX,UAAU,CAACW,aAAa;IACvCC,cAAc,EAAEZ,UAAU,CAACY,cAAc;AACzC;AACA;IACAC,WAAW,EAAE,CAACb,UAAU,CAACc,cAAc,IAAI,CAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAE,EAAEC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC5B,GAAG,CAACX,YAAY,CAAC;AACxFwC,IAAAA,MAAM,EAAExC,YAAY,CAACwB,UAAU,CAACiB,SAAS,CAAC;AAC1CC,IAAAA,MAAM,EAAE1C,YAAY,CAACwB,UAAU,CAACmB,SAAS,CAAC;AAC1CC,IAAAA,SAAS,EAAErB,KAAK,CAACqB,SAAS,GAAG,CAAC,GAAG;GACpC;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,gBAAgBA,CAACtB,KAAK,EAC/B;AACI,EAAA,MAAMC,UAAU,GAAGD,KAAK,CAACC,UAAU,IAAI,EAAE;EACzC,OAAO;IACHC,aAAa,EAAEF,KAAK,CAACE,aAAa;IAClCqB,aAAa,EAAEvB,KAAK,CAACuB,aAAa;AAClCpB,IAAAA,UAAU,EAAEF,UAAU,CAACE,UAAU,GAAG,CAAC,GAAG,CAAC;IACzCC,SAAS,EAAEH,UAAU,CAACG,SAAS;IAC/BC,SAAS,EAAEJ,UAAU,CAACI,SAAS;IAC/BC,SAAS,EAAEL,UAAU,CAACK,SAAS;IAC/BC,QAAQ,EAAEN,UAAU,CAACM,QAAQ;IAC7BC,QAAQ,EAAEP,UAAU,CAACO,QAAQ;IAC7BC,QAAQ,EAAER,UAAU,CAACQ,QAAQ;AAC7BC,IAAAA,UAAU,EAAEjC,YAAY,CAACwB,UAAU,CAACU,aAAa,CAAC;IAClDC,aAAa,EAAEX,UAAU,CAACW,aAAa;IACvCC,cAAc,EAAEZ,UAAU,CAACY,cAAc;IACzCC,WAAW,EAAEb,UAAU,CAACa,WAAW;AACnCG,IAAAA,MAAM,EAAExC,YAAY,CAACwB,UAAU,CAACiB,SAAS,CAAC;AAC1CC,IAAAA,MAAM,EAAE1C,YAAY,CAACwB,UAAU,CAACmB,SAAS;GAC5C;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASI,UAAUA,CAACxB,KAAK,EACzB;EACI,OAAO;IACHE,aAAa,EAAEF,KAAK,CAACE,aAAa;AAClCT,IAAAA,IAAI,EAAE9B,GAAG,CAACqC,KAAK,CAACP,IAAI,CAAC;IACrBH,IAAI,EAAEU,KAAK,CAACV,IAAI;IAChBmC,KAAK,EAAEzB,KAAK,CAAC0B,aAAa;AAC1BC,IAAAA,MAAM,EAAE3B,KAAK,CAAC2B,MAAM,GAAG,CAAC,GAAG,CAAC;AAC5BC,IAAAA,cAAc,EAAE5B,KAAK,CAAC4B,cAAc,GAAG,CAAC,GAAG;GAC9C;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,MAAMA,CAAC7B,KAAK,EACrB;EACI,OAAO;IACHE,aAAa,EAAEF,KAAK,CAACE,aAAa;AAClCT,IAAAA,IAAI,EAAE9B,GAAG,CAACqC,KAAK,CAACP,IAAI,CAAC;IACrBH,IAAI,EAAEU,KAAK,CAACV,IAAI;IAChBmC,KAAK,EAAEzB,KAAK,CAAC0B,aAAa;AAC1BE,IAAAA,cAAc,EAAE5B,KAAK,CAAC4B,cAAc,GAAG,CAAC,GAAG;GAC9C;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASE,YAAYA,CAACC,KAAK,EAC3B;AACI,EAAA,MAAMC,SAAS,GAAGD,KAAK,EAAEC,SAAS,IAAI,EAAE;AACxC,EAAA,MAAMC,UAAU,GAAGA,CAACrC,IAAI,EAAEC,KAAK,KAAKD,IAAI,CAACM,aAAa,GAAGL,KAAK,CAACK,aAAa;EAE5E,OAAO;IACHgC,SAAS,EAAE,CAACF,SAAS,CAACE,SAAS,IAAI,EAAE,EAAE9C,GAAG,CAAEY,KAAK,IACjD;AACI;AACA;AACA;AACA;AACA,MAAA,IAAIA,KAAK,CAACmC,UAAU,KAAKnC,KAAK,CAACoC,aAAa,EAC5C;AACI,QAAA,MAAM,IAAIC,mBAAmB,CACzB,kFAAkF,EAClF;UAAEF,UAAU,EAAEnC,KAAK,CAACmC,UAAU;UAAEC,aAAa,EAAEpC,KAAK,CAACoC;AAAc,SACvE,CAAC;AACL,MAAA;MACA,OAAO;QACHE,YAAY,EAAEtC,KAAK,CAACsC,YAAY;QAChCpC,aAAa,EAAEF,KAAK,CAACE,aAAa;QAClCkC,aAAa,EAAEpC,KAAK,CAACoC,aAAa;QAClCb,aAAa,EAAEvB,KAAK,CAACuB;OACxB;AACL,IAAA,CAAC,CAAC;IACFgB,cAAc,EAAE,CAACP,SAAS,CAACO,cAAc,IAAI,EAAE,EAAEnD,GAAG,CAACkC,gBAAgB,CAAC;IACtEkB,SAAS,EAAE,CAACT,KAAK,EAAES,SAAS,IAAI,EAAE,EAAEpD,GAAG,CAAEqD,QAAQ,KAAM;AACnDhD,MAAAA,IAAI,EAAE9B,GAAG,CAAC8E,QAAQ,CAAChD,IAAI,CAAC;MACxB5B,MAAM,EAAE4E,QAAQ,CAAC5E,MAAM;MACvBO,IAAI,EAAEqE,QAAQ,CAACrE,IAAI;MACnBkB,IAAI,EAAEmD,QAAQ,CAACnD,IAAI;MACnBoD,SAAS,EAAED,QAAQ,CAACC,SAAS;MAC7BC,QAAQ,EAAEF,QAAQ,CAACE,QAAQ;AAC3BhB,MAAAA,MAAM,EAAEc,QAAQ,CAACd,MAAM,GAAG,CAAC,GAAG,CAAC;AAC/BC,MAAAA,cAAc,EAAEa,QAAQ,CAACb,cAAc,GAAG,CAAC,GAAG;AAClD,KAAC,CAAC,CAAC;AACHgB,IAAAA,aAAa,EAAE7E,IAAI,CACfgE,KAAK,EAAEc,gBAAgB,EAAE7E,KAAK,EAC9B+D,KAAK,EAAEc,gBAAgB,EAAEC,kBAC7B,CAAC;AACDC,IAAAA,QAAQ,EAAE,CAAChB,KAAK,EAAEiB,SAAS,IAAI,EAAE,EAAE5D,GAAG,CAACoC,UAAU,CAAC,CAAC7B,IAAI,CAACsC,UAAU,CAAC;AACnEgB,IAAAA,QAAQ,EAAE,CAAClB,KAAK,EAAEkB,QAAQ,IAAI,EAAE,EAAE7D,GAAG,CAACW,UAAU,CAAC,CAACJ,IAAI,CAACsC,UAAU,CAAC;AAClEiB,IAAAA,IAAI,EAAE,CAACnB,KAAK,EAAEmB,IAAI,IAAI,EAAE,EAAE9D,GAAG,CAACyC,MAAM,CAAC,CAAClC,IAAI,CAACsC,UAAU,CAAC;AACtD9C,IAAAA,WAAW,EAAED,cAAc,CAAC6C,KAAK,EAAE5C,WAAW;GACjD;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASgE,QAAQA,CAACC,KAAK,EAAEC,OAAO,EAChC;EACI,MAAMrB,SAAS,GAAGoB,KAAK,CAACrB,KAAK,EAAEC,SAAS,IAAI,EAAE;AAC9C,EAAA,MAAMsB,OAAO,GAAGF,KAAK,CAACG,aAAa,IAAI,EAAE;AACzC,EAAA,MAAMC,eAAe,GAAGxB,SAAS,CAACwB,eAAe,IAAI,EAAE;AACvD,EAAA,MAAMC,WAAW,GAAGJ,OAAO,CAACK,UAAU,GAChCL,OAAO,CAACK,UAAU,CAACN,KAAK,EAAEC,OAAO,CAAC,GAClC,IAAI;EAEV,OAAO;IACH/D,IAAI,EAAE8D,KAAK,CAACO,SAAS;AACrB;AACA;AACA;AACA;IACAC,UAAU,EAAEH,WAAW,GACjB1F,IAAI,CAAC0F,WAAW,CAACzF,KAAK,EAAEyF,WAAW,CAACrF,IAAI,CAAC,GACzCL,IAAI,CAACuF,OAAO,CAACtF,KAAK,EAAEsF,OAAO,CAACO,UAAU,CAAC;AAC7CL,IAAAA,eAAe,EAAE,CACbA,eAAe,CAACM,CAAC,IAAI,CAAC,EACtBN,eAAe,CAACO,CAAC,IAAI,CAAC,EACtBP,eAAe,CAACQ,CAAC,IAAI,CAAC,CACzB;IACDC,cAAc,EAAE,CAACjC,SAAS,CAACiC,cAAc,IAAI,EAAE,EAAE7E,GAAG,CAAEY,KAAK,KAAM;MAC7DkE,KAAK,EAAElE,KAAK,CAACkE,KAAK;MAClBhE,aAAa,EAAEF,KAAK,CAACE,aAAa;MAClCiE,UAAU,EAAEnE,KAAK,CAACmE,UAAU;MAC5BC,QAAQ,EAAEpE,KAAK,CAACoE,QAAQ;MACxB9E,IAAI,EAAEU,KAAK,CAACV,IAAI;MAChBoD,SAAS,EAAE1C,KAAK,CAAC0C;AACrB,KAAC,CAAC,CAAC;AACH,IAAA,GAAGZ,YAAY,CAACsB,KAAK,CAACrB,KAAK;GAC9B;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASsC,UAAUA,CAACC,OAAO,EAC3B;AACI,EAAA,MAAMhB,OAAO,GAAGgB,OAAO,CAACf,aAAa,IAAI,EAAE;EAC3C,OAAO;AACHgB,IAAAA,WAAW,EAAED,OAAO,CAACC,WAAW,KAAK,CAAC;IACtCX,UAAU,EAAE7F,IAAI,CAACuF,OAAO,CAACtF,KAAK,EAAEsF,OAAO,CAACO,UAAU,CAAC;IACnDW,OAAO,EAAE,CAACF,OAAO,CAACE,OAAO,IAAI,EAAE,EAAEpF,GAAG,CAAEY,KAAK,KAAM;MAC7CV,IAAI,EAAEU,KAAK,CAACV,IAAI;AAChBG,MAAAA,IAAI,EAAE9B,GAAG,CAACqC,KAAK,CAACP,IAAI;AACxB,KAAC,CAAC,CAAC;AACHgF,IAAAA,YAAY,EAAE9G,GAAG,CAAC2G,OAAO,CAACG,YAAY,CAAC;AACvCC,IAAAA,YAAY,EAAE5C,YAAY,CAACwC,OAAO,CAACK,WAAW,CAAC;AAC/CC,IAAAA,WAAW,EAAE9C,YAAY,CAACwC,OAAO,CAACO,UAAU;GAC/C;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,6BAA6BA,CAACC,UAAU,EAAEC,KAAK,GAAG,EAAE,EACpE;AACI,EAAA,MAAMC,MAAM,GAAGF,UAAU,EAAEE,MAAM;EACjC,IAAI,CAACA,MAAM,EACX;AACI,IAAA,MAAM,IAAI5C,mBAAmB,CAAC,mCAAmC,EAAE,EAAE,CAAC;AAC1E,EAAA;EAEA,OAAO;IACH6C,UAAU,EAAE,CAACD,MAAM,CAACC,UAAU,IAAI,EAAE,EAAE9F,GAAG,CAAE+F,SAAS,KAAM;AACtD1F,MAAAA,IAAI,EAAE9B,GAAG,CAACwH,SAAS,CAAC1F,IAAI,CAAC;AACzB2F,MAAAA,MAAM,EAAE,CAACD,SAAS,CAACC,MAAM,IAAI,EAAE,EAAEhG,GAAG,CAAC,CAACiG,IAAI,EAAEC,SAAS,KACrD;AACI,QAAA,MAAMjC,OAAO,GAAG;UACZkC,aAAa,EAAEzH,MAAM,CAACqH,SAAS,CAAC1F,IAAI,IAAI,EAAE,CAAC;UAC3C6F,SAAS;AACTE,UAAAA,OAAO,EAAE,CAAA,EAAGL,SAAS,CAAC1F,IAAI,CAAA,KAAA,EAAQ6F,SAAS,CAAA,CAAE;UAC7C5B,UAAU,EAAEsB,KAAK,CAACtB;SACrB;AACD,QAAA,MAAM+B,KAAK,GAAGT,KAAK,CAACU,eAAe,GAC7BV,KAAK,CAACU,eAAe,CAACrC,OAAO,EAAEgC,IAAI,CAAC,GACpC,IAAI;QAEV,OAAO;AACHM,UAAAA,MAAM,EAAE,CAACN,IAAI,CAACM,MAAM,IAAI,EAAE,EAAEvG,GAAG,CAAEgE,KAAK,IAAKD,QAAQ,CAACC,KAAK,EAAEC,OAAO,CAAC,CAAC;UACpEuC,YAAY,EAAE,CAACP,IAAI,CAACO,YAAY,IAAI,EAAE,EACjCxG,GAAG,CAAEY,KAAK,KAAM;AAAE6F,YAAAA,KAAK,EAAE7F,KAAK,CAAC6F,KAAK,KAAK,CAAC;AAAEjI,YAAAA,KAAK,EAAEoC,KAAK,CAACpC,KAAK,KAAK;AAAE,WAAC,CAAC,CAAC,CACxE+B,IAAI,CAAC,CAACC,IAAI,EAAEC,KAAK,KAAKD,IAAI,CAACiG,KAAK,GAAGhG,KAAK,CAACgG,KAAK,CAAC;AACpD,UAAA,IAAIJ,KAAK,GAAG;YAAEK,YAAY,EAAE/H,IAAI,CAAC0H,KAAK;WAAG,GAAG,EAAE;SACjD;AACL,MAAA,CAAC,CAAC;MACFM,SAAS,EAAE,CAACZ,SAAS,CAACY,SAAS,IAAI,EAAE,EAAE3G,GAAG,CAACiF,UAAU;AACzD,KAAC,CAAC,CAAC;IACHlF,WAAW,EAAE,CAAC8F,MAAM,CAAC9F,WAAW,IAAI,EAAE,EACjCC,GAAG,CAAE4G,KAAK,KAAM;AACbvG,MAAAA,IAAI,EAAE9B,GAAG,CAACqI,KAAK,CAACC,aAAa,CAAC;AAC9B9G,MAAAA,WAAW,EAAED,cAAc,CAAC8G,KAAK,CAAC7G,WAAW;KAChD,CAAC,CAAC,CACFQ,IAAI,CAAC,CAACC,IAAI,EAAEC,KAAK,KAAKC,WAAW,CAACF,IAAI,CAACH,IAAI,CAAC7B,KAAK,EAAEiC,KAAK,CAACJ,IAAI,CAAC7B,KAAK,CAAC;GAC5E;AACL;;;;"}