@amazon/vinyl-mpd-parser 3.2.3-next.20261010160052 → 3.2.3-next.20261013174635

package/dist/test/benchmark.js

@@ -925,9 +925,9 @@
     cyclicRefError: "Cyclic reference found at: {path}",
     mergeReferenceError: `No merge rule found at {path} for "{source}" and reference copy not allowed`
   };
-  function mergeDeep(sources, options) {
+  function mergeDeep(sources, options2) {
     if (!sources.length) return void 0;
-    const finalOpts = __spreadValues(__spreadValues({}, defaultMergeOptions), options);
+    const finalOpts = __spreadValues(__spreadValues({}, defaultMergeOptions), options2);
     const stack = new PropStack();
     const n = sources.length;
     if (n === 1)
@@ -976,12 +976,12 @@
       refSet.add(source);
     }
   };
-  function _mergeDeep(sourceA, sourceB, propStack, prop, options) {
+  function _mergeDeep(sourceA, sourceB, propStack, prop, options2) {
     if (typeof sourceB !== "object" || sourceB === null) return sourceB;
     const merge = (sourceA2, sourceB2, prop2) => {
-      return _mergeDeep(sourceA2, sourceB2, propStack, prop2, options);
+      return _mergeDeep(sourceA2, sourceB2, propStack, prop2, options2);
     };
-    for (const rule of options.rules) {
+    for (const rule of options2.rules) {
       if (rule.matches(sourceB)) {
         propStack.push(sourceA, sourceB, prop);
         const result = rule.merge(
@@ -993,7 +993,7 @@
         return result;
       }
     }
-    if (!options.allowReferenceCopy) {
+    if (!options2.allowReferenceCopy) {
       propStack.push(sourceA, sourceB, prop);
       throw new MergeReferenceError(propStack.currentPath, sourceB);
     }
@@ -1138,11 +1138,11 @@
   };
 
   // ../vinyl-util/src/util/object/clone.ts
-  function clone(target, options) {
+  function clone(target, options2) {
     var _a2, _b, _c;
     return mergeDeep([target], {
-      allowReferenceCopy: (_a2 = options == null ? void 0 : options.allowReferenceCopy) != null ? _a2 : false,
-      rules: (_c = (_b = options == null ? void 0 : options.rules) == null ? void 0 : _b.map(toMergeRule)) != null ? _c : defaultMergeOptions.rules
+      allowReferenceCopy: (_a2 = options2 == null ? void 0 : options2.allowReferenceCopy) != null ? _a2 : false,
+      rules: (_c = (_b = options2 == null ? void 0 : options2.rules) == null ? void 0 : _b.map(toMergeRule)) != null ? _c : defaultMergeOptions.rules
     });
   }
   function toMergeRule(cloneRule) {
@@ -1180,15 +1180,15 @@
   }
 
   // ../vinyl-util/src/util/serialization/ParseError.ts
-  function printStringPosition(str, index, options) {
+  function printStringPosition(str, index, options2) {
     var _a2;
-    const caret = (options == null ? void 0 : options.caret) || "^";
+    const caret = (options2 == null ? void 0 : options2.caret) || "^";
     index = clamp(index, 0, str.length);
     const minIndex = str.lastIndexOf("\n", index - 1) + 1;
     let maxIndex = str.indexOf("\n", index);
     if (maxIndex === -1) maxIndex = str.length;
-    const split = (options == null ? void 0 : options.split) === void 0 ? 0.6 : options.split;
-    const cols = ((_a2 = options == null ? void 0 : options.maxColumns) != null ? _a2 : 60) - caret.length;
+    const split = (options2 == null ? void 0 : options2.split) === void 0 ? 0.6 : options2.split;
+    const cols = ((_a2 = options2 == null ? void 0 : options2.maxColumns) != null ? _a2 : 60) - caret.length;
     let leadingChars = cols * split;
     let trailingChars = cols * (1 - split);
     const maxLeadingChars = index - minIndex;
@@ -1571,8 +1571,8 @@
       isValid(input) {
         return validate(input, { all: false }, []).length === 0;
       },
-      validate(input, options, path = []) {
-        return validate(input, options != null ? options : { all: false }, path);
+      validate(input, options2, path = []) {
+        return validate(input, options2 != null ? options2 : { all: false }, path);
       },
       assert: (input, origin, path = []) => {
         const errors = validate(input, { all: false }, path);
@@ -1629,9 +1629,9 @@
       substitute(locale5.template, {
         value: validators.map((v) => v.description).join(locale5.separator)
       }),
-      (input, options, path) => {
+      (input, options2, path) => {
         for (const validator of validators) {
-          const errors = validator.validate(input, options, path);
+          const errors = validator.validate(input, options2, path);
           if (errors.length) return errors;
         }
         return [];
@@ -1663,11 +1663,11 @@
     });
     return createDeepValidator(
       description,
-      (input, options, path) => {
+      (input, options2, path) => {
         let longestErrors = [];
         let longestPath = 0;
         for (const validator of validators) {
-          const errors = validator.validate(input, options, path);
+          const errors = validator.validate(input, options2, path);
           if (!errors.length) return errors;
           const pathLength = errors.reduce(
             (max, m) => Math.max(m.path.length, max),
@@ -1710,7 +1710,7 @@
         this.validator.assert(input, origin, path);
       });
       __publicField(this, "isValid", (input) => this.validator.isValid(input));
-      __publicField(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
+      __publicField(this, "validate", (input, options2, path) => this.validator.validate(input, options2, path));
       this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
     }
     get options() {
@@ -2144,17 +2144,17 @@
   }
 
   // ../vinyl-xml/src/xml/xmlRules.ts
-  function element(rules, options) {
+  function element(rules, options2) {
     return __spreadProps(__spreadValues({
       type: "element" /* ELEMENT */,
       localPart: void 0,
       namespaceUri: void 0,
       required: false
-    }, options), {
+    }, options2), {
       rules
     });
   }
-  function elements(rules, options) {
+  function elements(rules, options2) {
     return __spreadProps(__spreadValues({
       type: "elements" /* ELEMENTS */,
       localPart: void 0,
@@ -2162,7 +2162,7 @@
       minOccurs: 0,
       maxOccurs: null,
       useEmptyArrays: false
-    }, options), {
+    }, options2), {
       rules
     });
   }
@@ -2170,32 +2170,32 @@
     return { type: "characters" /* CHARACTERS */, parse, stringify: stringify2 };
   }
   var charactersString = characters((i) => i, stringify);
-  function attr(parse, stringify2, options) {
+  function attr(parse, stringify2, options2) {
     return __spreadProps(__spreadValues({
       type: "attribute" /* ATTRIBUTE */,
       localPart: void 0,
       namespaceUri: null,
       required: false,
       default: void 0
-    }, options), {
+    }, options2), {
       parse,
       stringify: stringify2
     });
   }
-  function attrString(options) {
-    return attr((i) => i, stringify, options);
+  function attrString(options2) {
+    return attr((i) => i, stringify, options2);
   }
-  function attrInt(options) {
-    return attr(parseInt, stringify, options);
+  function attrInt(options2) {
+    return attr(parseInt, stringify, options2);
   }
-  function attrFloat(options) {
-    return attr(parseFloat, stringify, options);
+  function attrFloat(options2) {
+    return attr(parseFloat, stringify, options2);
   }
-  function attrBoolean(options) {
-    return attr(parseBoolean, stringify, options);
+  function attrBoolean(options2) {
+    return attr(parseBoolean, stringify, options2);
   }
-  function attrDateTime(options) {
-    return attr(parseDate, stringifyDate, options);
+  function attrDateTime(options2) {
+    return attr(parseDate, stringifyDate, options2);
   }
 
   // ../vinyl-xml/src/xml/mappedXmlRules.ts
@@ -2624,12 +2624,12 @@
     return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
   }
   var ParseXmlHandlerImpl = class {
-    constructor(rules, options) {
+    constructor(rules, options2) {
       __publicField(this, "rules", rules);
       __publicField(this, "stack", []);
       __publicField(this, "options");
       __publicField(this, "busy", false);
-      this.options = __spreadValues({ validateRules: true }, options);
+      this.options = __spreadValues({ validateRules: true }, options2);
     }
     startDocument() {
       if (this.busy)
@@ -2836,10 +2836,13 @@
 
   // src/manifest/dashManifestXmlRules.ts
   var dashNamespaceUri = "urn:mpeg:dash:schema:mpd:2011";
+  var XLINK_NAMESPACE_URI = "http://www.w3.org/1999/xlink";
   function dashManifestXmlRules() {
     const attrActuateType = attr(assertActuateEnum, stringify, {
-      default: "onRequest"
+      default: "onRequest",
+      namespaceUri: XLINK_NAMESPACE_URI
     });
+    const attrHref = attrString({ namespaceUri: XLINK_NAMESPACE_URI });
     const descriptorType = {
       id: attrString,
       schemeIdUri: attrString({ required: true }),
@@ -2900,7 +2903,7 @@
     };
     const segmentListType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
       actuate: attrActuateType,
-      href: attrString,
+      href: attrHref,
       SegmentURL: elements(segmentURLType)
     });
     const segmentTemplateType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
@@ -2913,19 +2916,32 @@
       contains: attr(parseIntVector, stringifyIntVector, { required: true }),
       id: attrString
     };
+    const alternativePresentationType = {
+      uri: attrString,
+      maxDuration: attrInt,
+      earliestResolutionTimeOffset: attrInt,
+      returnOffset: attrInt,
+      clip: attrBoolean,
+      startWithOffset: attrBoolean
+    };
     const eventType = {
       duration: attrInt,
       id: attrInt,
       messageData: attrString,
-      presentationTime: attrInt({ default: 0 })
+      presentationTime: attrInt({ default: 0 }),
+      contentEncoding: attrString,
+      _content: charactersString,
+      InsertPresentation: element(alternativePresentationType),
+      ReplacePresentation: element(alternativePresentationType)
     };
     const eventStreamType = {
       Event: elements(eventType),
       actuate: attrActuateType,
-      href: attrString,
+      href: attrHref,
       messageData: attrString,
       schemeIdUri: attrString({ required: true }),
       timescale: attrInt,
+      presentationTimeOffset: attrInt,
       value: attrString
     };
     const switchingType = {
@@ -2989,7 +3005,7 @@
       bitstreamSwitching: attrBoolean,
       contentType: attrString,
       group: attrInt,
-      href: attrString,
+      href: attrHref,
       id: attrInt,
       lang: attrString,
       maxBandwidth: attrInt,
@@ -3021,6 +3037,10 @@
       Range: elements(rangeType),
       Reporting: elements(descriptorType, { minOccurs: 1 })
     };
+    const importedMpdType = {
+      earliestResolutionTimeOffset: attrFloat,
+      _content: charactersString
+    };
     const periodType = {
       BaseURL: elements(baseURLType),
       SegmentBase: element(segmentBaseType),
@@ -3031,10 +3051,11 @@
       AdaptationSet: elements(adaptationSetType),
       Subset: elements(subsetType),
       SupplementalProperty: elements(descriptorType),
+      ImportedMPD: element(importedMpdType),
       actuate: attrActuateType,
       bitstreamSwitching: attrBoolean({ default: false }),
       duration: attr(parseDuration, stringifyDuration),
-      href: attrString,
+      href: attrHref,
       id: attrString,
       start: attr(parseDuration, stringifyDuration)
     };
@@ -3122,7 +3143,8 @@
   }
   var presentationTypeValidator = isOneOf(
     "static",
-    "dynamic"
+    "dynamic",
+    "list"
   );
   function parsePresentationTypeType(str) {
     presentationTypeValidator.assert(str, ErrorOrigin.PARSING);
@@ -3201,11 +3223,92 @@
     )
   };
 
+  // src/xmlns/scte/35/2016.ts
+  var SCTE35_2016_NAMESPACE_URI = "http://www.scte.org/schemas/35/2016";
+
+  // src/manifest/ext/events/scte35XmlRules.ts
+  var options = { namespaceUri: SCTE35_2016_NAMESPACE_URI };
+  var spliceTimeType = {
+    ptsTime: attrInt
+  };
+  var segmentationUpidType = {
+    segmentationUpidType: attrInt,
+    segmentationUpidFormat: attrString,
+    _content: charactersString
+  };
+  var segmentationDescriptorType = {
+    segmentationEventId: attrInt,
+    segmentationEventCancelIndicator: attrBoolean,
+    segmentationDuration: attrInt,
+    segmentationTypeId: attrInt,
+    segmentNum: attrInt,
+    segmentsExpected: attrInt,
+    SegmentationUpid: elements(segmentationUpidType, options)
+  };
+  var programType = {
+    SpliceTime: element(spliceTimeType, options)
+  };
+  var breakDurationType = {
+    autoReturn: attrBoolean,
+    duration: attrInt
+  };
+  var spliceInsertType = {
+    spliceEventId: attrInt,
+    spliceEventCancelIndicator: attrBoolean,
+    outOfNetworkIndicator: attrBoolean,
+    spliceImmediateFlag: attrBoolean,
+    uniqueProgramId: attrInt,
+    availNum: attrInt,
+    availsExpected: attrInt,
+    Program: element(programType, options),
+    BreakDuration: element(breakDurationType, options)
+  };
+  var timeSignalType = {
+    SpliceTime: element(spliceTimeType, options)
+  };
+  var spliceNullType = {};
+  var spliceInfoSectionType = {
+    ptsAdjustment: attrInt,
+    tier: attrInt,
+    SpliceNull: element(spliceNullType, options),
+    SpliceInsert: element(spliceInsertType, options),
+    TimeSignal: element(timeSignalType, options),
+    SegmentationDescriptor: elements(segmentationDescriptorType, options)
+  };
+  var binaryType = {
+    _content: charactersString
+  };
+  var signalType = {
+    Binary: element(binaryType, options)
+  };
+  var scte35EventXmlRules = {
+    Signal: element(signalType, options),
+    SpliceInfoSection: element(spliceInfoSectionType, options)
+  };
+  function createDashScte35EventXmlRules() {
+    return {
+      MPD: element(
+        {
+          Period: elements(
+            {
+              EventStream: elements({
+                Event: elements(scte35EventXmlRules)
+              })
+            },
+            { minOccurs: 1 }
+          )
+        },
+        { required: true, namespaceUri: dashNamespaceUri }
+      )
+    };
+  }
+
   // src/manifest/dashParser.ts
   var dashDrmRules = mergeXmlRules(
     dashManifestXmlRules(),
     createDashProtectionXmlRules(cencXmlRules),
-    createDashProtectionXmlRules(playreadyXmlRules)
+    createDashProtectionXmlRules(playreadyXmlRules),
+    createDashScte35EventXmlRules()
   );
   var dashDrmRulesMapped = mapXmlRules(dashDrmRules);
   function dashManifestHandler() {
@@ -3337,11 +3440,11 @@
      * promise will be awaited. The executor should either always return a promise, or never.
      * @param options Optional configuration for the benchmark.
      */
-    constructor(name, executor, options) {
+    constructor(name, executor, options2) {
       __publicField(this, "name", name);
       __publicField(this, "executor", executor);
       __publicField(this, "options");
-      this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options);
+      this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options2);
     }
     async run() {
       const opts = this.options;
@@ -3391,8 +3494,8 @@
   };
   __publicField(_Benchmark, "semaphore", nextFrame());
   var Benchmark = _Benchmark;
-  function benchmark(name, executor, options) {
-    const benchmark2 = new Benchmark(name, executor, options);
+  function benchmark(name, executor, options2) {
+    const benchmark2 = new Benchmark(name, executor, options2);
     return benchmark2.run().then((results) => {
       console.log(results.toString());
       return results;
@@ -4019,8 +4122,8 @@
     });
     return container;
   }
-  function createEl(tagName, parent, options) {
-    const element2 = document.createElement(tagName, options);
+  function createEl(tagName, parent, options2) {
+    const element2 = document.createElement(tagName, options2);
     if (parent) parent.appendChild(element2);
     return element2;
   }