@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/render.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _require = require("./errors.js"),
+  throwUnimplementedTagType = _require.throwUnimplementedTagType,
+  XTScopeParserError = _require.XTScopeParserError;
+var _require2 = require("./doc-utils.js"),
+  pushArray = _require2.pushArray;
+var getResolvedId = require("./get-resolved-id.js");
+function moduleRender(part, options) {
+  for (var _i2 = 0, _options$modules2 = options.modules; _i2 < _options$modules2.length; _i2++) {
+    var _module = _options$modules2[_i2];
+    var moduleRendered = _module.render(part, options);
+    if (moduleRendered) {
+      return moduleRendered;
+    }
+  }
+  return false;
+}
+function render(options) {
+  var baseNullGetter = options.baseNullGetter;
+  var compiled = options.compiled,
+    scopeManager = options.scopeManager;
+  options.nullGetter = function (part, sm) {
+    return baseNullGetter(part, sm || scopeManager);
+  };
+  var errors = [];
+  var parts = compiled.map(function (part, i) {
+    options.index = i;
+    options.resolvedId = getResolvedId(part, options);
+    var moduleRendered;
+    try {
+      moduleRendered = moduleRender(part, options);
+    } catch (e) {
+      if (e instanceof XTScopeParserError) {
+        errors.push(e);
+        return part;
+      }
+      throw e;
+    }
+    if (moduleRendered) {
+      if (moduleRendered.errors) {
+        Array.prototype.push.apply(errors, moduleRendered.errors);
+      }
+      return moduleRendered;
+    }
+    if (part.type === "content" || part.type === "tag") {
+      return part;
+    }
+    throwUnimplementedTagType(part, i);
+  }).reduce(function (parts, _ref) {
+    var value = _ref.value;
+    if (value instanceof Array) {
+      pushArray(parts, value);
+    } else if (value) {
+      parts.push(value);
+    }
+    return parts;
+  }, []);
+  return {
+    errors: errors,
+    parts: parts
+  };
+}
+module.exports = render;

package/dist/node_modules/docxtemplater/js/resolve.js

@@ -0,0 +1,82 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var getResolvedId = require("./get-resolved-id.js");
+function moduleResolve(part, options) {
+  for (var _i2 = 0, _options$modules2 = options.modules; _i2 < _options$modules2.length; _i2++) {
+    var _module = _options$modules2[_i2];
+    var moduleResolved = _module.resolve(part, options);
+    if (moduleResolved) {
+      return moduleResolved;
+    }
+  }
+  return false;
+}
+function resolve(options) {
+  var resolved = [];
+  var baseNullGetter = options.baseNullGetter;
+  var compiled = options.compiled,
+    scopeManager = options.scopeManager;
+  options.nullGetter = function (part, sm) {
+    return baseNullGetter(part, sm || scopeManager);
+  };
+  options.resolved = resolved;
+  var errors = [];
+  return Promise.all(compiled.filter(function (part) {
+    return ["content", "tag"].indexOf(part.type) === -1;
+  }).reduce(function (promises, part) {
+    var moduleResolved = moduleResolve(part, _objectSpread(_objectSpread({}, options), {}, {
+      resolvedId: getResolvedId(part, options)
+    }));
+    var result;
+    if (moduleResolved) {
+      result = moduleResolved.then(function (value) {
+        resolved.push({
+          tag: part.value,
+          lIndex: part.lIndex,
+          value: value
+        });
+      });
+    } else if (part.type === "placeholder") {
+      result = scopeManager.getValueAsync(part.value, {
+        part: part
+      }).then(function (value) {
+        return value == null ? options.nullGetter(part) : value;
+      }).then(function (value) {
+        resolved.push({
+          tag: part.value,
+          lIndex: part.lIndex,
+          value: value
+        });
+        return value;
+      });
+    } else {
+      return;
+    }
+    promises.push(result["catch"](function (e) {
+      if (e instanceof Array) {
+        errors.push.apply(errors, _toConsumableArray(e));
+      } else {
+        errors.push(e);
+      }
+    }));
+    return promises;
+  }, [])).then(function () {
+    return {
+      errors: errors,
+      resolved: resolved
+    };
+  });
+}
+module.exports = resolve;

package/dist/node_modules/docxtemplater/js/scope-manager.js

@@ -0,0 +1,229 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var _require = require("./errors.js"),
+  getScopeParserExecutionError = _require.getScopeParserExecutionError;
+var _require2 = require("./utils.js"),
+  last = _require2.last;
+var _require3 = require("./doc-utils.js"),
+  concatArrays = _require3.concatArrays;
+function find(list, fn) {
+  var length = list.length >>> 0;
+  var value;
+  for (var i = 0; i < length; i++) {
+    value = list[i];
+    if (fn.call(this, value, i, list)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+function _getValue(tag, meta, num) {
+  var _this = this;
+  var scope = this.scopeList[num];
+  if (this.root.finishedResolving) {
+    var w = this.resolved;
+    var _loop = function _loop() {
+      var lIndex = _this.scopeLindex[i];
+      w = find(w, function (r) {
+        return r.lIndex === lIndex;
+      });
+      w = w.value[_this.scopePathItem[i]];
+    };
+    for (var i = this.resolveOffset, len = this.scopePath.length; i < len; i++) {
+      _loop();
+    }
+    return find(w, function (r) {
+      return meta.part.lIndex === r.lIndex;
+    }).value;
+  }
+  // search in the scopes (in reverse order) and keep the first defined value
+  var result;
+  var parser;
+  if (!this.cachedParsers || !meta.part) {
+    parser = this.parser(tag, {
+      tag: meta.part,
+      scopePath: this.scopePath
+    });
+  } else if (this.cachedParsers[meta.part.lIndex]) {
+    parser = this.cachedParsers[meta.part.lIndex];
+  } else {
+    parser = this.cachedParsers[meta.part.lIndex] = this.parser(tag, {
+      tag: meta.part,
+      scopePath: this.scopePath
+    });
+  }
+  try {
+    result = parser.get(scope, this.getContext(meta, num));
+  } catch (error) {
+    throw getScopeParserExecutionError({
+      tag: tag,
+      scope: scope,
+      error: error,
+      offset: meta.part.offset
+    });
+  }
+  if (result == null && num > 0) {
+    return _getValue.call(this, tag, meta, num - 1);
+  }
+  return result;
+}
+function _getValueAsync(tag, meta, num) {
+  var _this2 = this;
+  var scope = this.scopeList[num];
+  // search in the scopes (in reverse order) and keep the first defined value
+  var parser;
+  if (!this.cachedParsers || !meta.part) {
+    parser = this.parser(tag, {
+      tag: meta.part,
+      scopePath: this.scopePath
+    });
+  } else if (this.cachedParsers[meta.part.lIndex]) {
+    parser = this.cachedParsers[meta.part.lIndex];
+  } else {
+    parser = this.cachedParsers[meta.part.lIndex] = this.parser(tag, {
+      tag: meta.part,
+      scopePath: this.scopePath
+    });
+  }
+  return Promise.resolve().then(function () {
+    return parser.get(scope, _this2.getContext(meta, num));
+  })["catch"](function (error) {
+    throw getScopeParserExecutionError({
+      tag: tag,
+      scope: scope,
+      error: error,
+      offset: meta.part.offset
+    });
+  }).then(function (result) {
+    if (result == null && num > 0) {
+      return _getValueAsync.call(_this2, tag, meta, num - 1);
+    }
+    return result;
+  });
+}
+var ScopeManager = /*#__PURE__*/function () {
+  function ScopeManager(options) {
+    _classCallCheck(this, ScopeManager);
+    this.root = options.root || this;
+    this.resolveOffset = options.resolveOffset || 0;
+    this.scopePath = options.scopePath;
+    this.scopePathItem = options.scopePathItem;
+    this.scopePathLength = options.scopePathLength;
+    this.scopeList = options.scopeList;
+    this.scopeType = "";
+    this.scopeTypes = options.scopeTypes;
+    this.scopeLindex = options.scopeLindex;
+    this.parser = options.parser;
+    this.resolved = options.resolved;
+    this.cachedParsers = options.cachedParsers;
+  }
+  return _createClass(ScopeManager, [{
+    key: "loopOver",
+    value: function loopOver(tag, functor, inverted, meta) {
+      return this.loopOverValue(this.getValue(tag, meta), functor, inverted);
+    }
+  }, {
+    key: "functorIfInverted",
+    value: function functorIfInverted(inverted, functor, value, i, length) {
+      if (inverted) {
+        functor(value, i, length);
+      }
+      return inverted;
+    }
+  }, {
+    key: "isValueFalsy",
+    value: function isValueFalsy(value, type) {
+      return value == null || !value || type === "[object Array]" && value.length === 0;
+    }
+  }, {
+    key: "loopOverValue",
+    value: function loopOverValue(value, functor, inverted) {
+      if (this.root.finishedResolving) {
+        inverted = false;
+      }
+      var type = Object.prototype.toString.call(value);
+      if (this.isValueFalsy(value, type)) {
+        this.scopeType = false;
+        return this.functorIfInverted(inverted, functor, last(this.scopeList), 0, 1);
+      }
+      if (type === "[object Array]") {
+        this.scopeType = "array";
+        for (var i = 0; i < value.length; i++) {
+          this.functorIfInverted(!inverted, functor, value[i], i, value.length);
+        }
+        return true;
+      }
+      if (type === "[object Object]") {
+        this.scopeType = "object";
+        return this.functorIfInverted(!inverted, functor, value, 0, 1);
+      }
+      return this.functorIfInverted(!inverted, functor, last(this.scopeList), 0, 1);
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(tag, meta) {
+      var result = _getValue.call(this, tag, meta, this.scopeList.length - 1);
+      if (typeof result === "function") {
+        return result(this.scopeList[this.scopeList.length - 1], this);
+      }
+      return result;
+    }
+  }, {
+    key: "getValueAsync",
+    value: function getValueAsync(tag, meta) {
+      var _this3 = this;
+      return _getValueAsync.call(this, tag, meta, this.scopeList.length - 1).then(function (result) {
+        if (typeof result === "function") {
+          return result(_this3.scopeList[_this3.scopeList.length - 1], _this3);
+        }
+        return result;
+      });
+    }
+  }, {
+    key: "getContext",
+    value: function getContext(meta, num) {
+      return {
+        num: num,
+        meta: meta,
+        scopeList: this.scopeList,
+        resolved: this.resolved,
+        scopePath: this.scopePath,
+        scopeTypes: this.scopeTypes,
+        scopePathItem: this.scopePathItem,
+        scopePathLength: this.scopePathLength
+      };
+    }
+  }, {
+    key: "createSubScopeManager",
+    value: function createSubScopeManager(scope, tag, i, part, length) {
+      return new ScopeManager({
+        root: this.root,
+        resolveOffset: this.resolveOffset,
+        resolved: this.resolved,
+        parser: this.parser,
+        cachedParsers: this.cachedParsers,
+        scopeTypes: concatArrays([this.scopeTypes, [this.scopeType]]),
+        scopeList: concatArrays([this.scopeList, [scope]]),
+        scopePath: concatArrays([this.scopePath, [tag]]),
+        scopePathItem: concatArrays([this.scopePathItem, [i]]),
+        scopePathLength: concatArrays([this.scopePathLength, [length]]),
+        scopeLindex: concatArrays([this.scopeLindex, [part.lIndex]])
+      });
+    }
+  }]);
+}();
+module.exports = function (options) {
+  options.scopePath = [];
+  options.scopePathItem = [];
+  options.scopePathLength = [];
+  options.scopeTypes = [];
+  options.scopeLindex = [];
+  options.scopeList = [options.tags];
+  return new ScopeManager(options);
+};

package/dist/node_modules/docxtemplater/js/test-text.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var TxtTemplater = require("../text.js");
+var doc = new TxtTemplater("Hello {user}, how are you ?");
+var result = doc.render({
+  user: "John"
+});
+if (result !== "Hello John, how are you ?") {
+  // eslint-disable-next-line no-console
+  console.log(result);
+  throw new Error("TxtTemplater did not work as expected");
+}

package/dist/node_modules/docxtemplater/js/tests/assertion-module.js

@@ -0,0 +1,163 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function logContext(parsed, i) {
+  var context = parsed.slice(i - 2, i + 2);
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify({
+    context: context
+  }));
+}
+function isArray(thing) {
+  return thing instanceof Array;
+}
+function isObject(thing) {
+  return thing instanceof Object && !isArray(thing);
+}
+function isString(thing) {
+  return typeof thing === "string";
+}
+function verifyPart(part) {
+  if (part == null) {
+    throw new Error("postparsed contains nullish value");
+  }
+  if (!part) {
+    throw new Error("postparsed contains falsy value");
+  }
+  if (typeof part.type !== "string") {
+    throw new Error("postparsed contains part without type");
+  }
+  if (["content", "tag", "placeholder"].indexOf(part.type) === -1) {
+    throw new Error("postparsed contains part with invalid type : '".concat(part.type, "'"));
+  }
+}
+function verifyOptions(options) {
+  if (!isString(options.contentType)) {
+    throw new Error("contentType should be a string");
+  }
+  if (!isString(options.filePath)) {
+    throw new Error("filePath should be a string");
+  }
+  if (!isString(options.fileType)) {
+    throw new Error("fileType should be a string");
+  }
+  if (!isObject(options.fileTypeConfig)) {
+    throw new Error("fileTypeConfig should be an object");
+  }
+  if (!isObject(options.cachedParsers)) {
+    throw new Error("cachedParsers should be an object");
+  }
+}
+var AssertionModule = /*#__PURE__*/function () {
+  function AssertionModule() {
+    _classCallCheck(this, AssertionModule);
+    this.name = "AssertionModule";
+  }
+  return _createClass(AssertionModule, [{
+    key: "optionsTransformer",
+    value: function optionsTransformer(options, docxtemplater) {
+      for (var _i2 = 0, _docxtemplater$module2 = docxtemplater.modules; _i2 < _docxtemplater$module2.length; _i2++) {
+        var _module = _docxtemplater$module2[_i2];
+        if (!_module.name) {
+          throw new Error("Unnamed module");
+        }
+      }
+      return options;
+    }
+  }, {
+    key: "clone",
+    value: function clone() {
+      return new AssertionModule();
+    }
+  }, {
+    key: "preparse",
+    value: function preparse(parsed) {
+      if (!isArray(parsed)) {
+        throw new Error("Parsed should be an array");
+      }
+    }
+  }, {
+    key: "matchers",
+    value: function matchers(options) {
+      if (!isArray(options.modules)) {
+        throw new Error("Options.modules should be an array");
+      }
+      return [];
+    }
+  }, {
+    key: "parse",
+    value: function parse(placeholderContent, options) {
+      if (!isString(placeholderContent)) {
+        throw new Error("placeholderContent should be a string");
+      }
+      var type = options.type,
+        position = options.position,
+        filePath = options.filePath,
+        contentType = options.contentType,
+        lIndex = options.lIndex;
+      if (typeof type !== "string") {
+        throw new Error("parsed contains part without type");
+      }
+      if (type !== "delimiter") {
+        throw new Error("parsed contains part with invalid type : '".concat(type, "'"));
+      }
+      if (position !== "end") {
+        throw new Error("parsed contains part with invalid position : '".concat(position, "'"));
+      }
+      if (typeof filePath !== "string" || filePath.length === 0) {
+        throw new Error("parsed contains part without filePath");
+      }
+      if (typeof contentType !== "string" || contentType.length === 0) {
+        throw new Error("parsed contains part without contentType");
+      }
+      if (!lIndex) {
+        throw new Error("parsed contains part without lIndex");
+      }
+    }
+  }, {
+    key: "postparse",
+    value: function postparse(parsed, options) {
+      verifyOptions(options);
+      if (!isArray(parsed)) {
+        throw new Error("Parsed should be an array");
+      }
+      for (var i = 0, len = parsed.length; i < len; i++) {
+        var part = parsed[i];
+        try {
+          verifyPart(part);
+        } catch (e) {
+          logContext(parsed, i);
+          throw e;
+        }
+      }
+    }
+  }, {
+    key: "resolve",
+    value: function resolve(part, options) {
+      verifyOptions(options);
+    }
+  }, {
+    key: "render",
+    value: function render(part, options) {
+      verifyPart(part);
+      verifyOptions(options);
+      if (!isObject(part)) {
+        throw new Error("part should be an object");
+      }
+    }
+  }, {
+    key: "postrender",
+    value: function postrender(parts) {
+      if (!isArray(parts)) {
+        throw new Error("Parts should be an array");
+      }
+      return parts;
+    }
+  }]);
+}();
+module.exports = AssertionModule;

package/dist/node_modules/docxtemplater/js/tests/data/raw-xml-pptx.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = "<p:sp>\n  <p:nvSpPr>\n    <p:cNvPr id=\"37\" name=\"CustomShape 2\"/>\n    <p:cNvSpPr/>\n    <p:nvPr/>\n  </p:nvSpPr>\n  <p:spPr>\n    <a:xfrm>\n      <a:off x=\"504000\" y=\"1769040\"/>\n      <a:ext cx=\"9071280\" cy=\"4384080\"/>\n    </a:xfrm>\n    <a:prstGeom prst=\"rect\">\n      <a:avLst/>\n    </a:prstGeom>\n    <a:noFill/>\n    <a:ln>\n      <a:noFill/>\n    </a:ln>\n  </p:spPr>\n  <p:style>\n    <a:lnRef idx=\"0\"/>\n    <a:fillRef idx=\"0\"/>\n    <a:effectRef idx=\"0\"/>\n    <a:fontRef idx=\"minor\"/>\n  </p:style>\n  <p:txBody>\n    <a:bodyPr lIns=\"0\" rIns=\"0\" tIns=\"0\" bIns=\"0\" anchor=\"ctr\"/>\n    <a:p>\n      <a:pPr algn=\"ctr\">\n        <a:lnSpc>\n          <a:spcPct val=\"100000\"/>\n        </a:lnSpc>\n      </a:pPr>\n      <a:r>\n        <a:rPr b=\"0\" lang=\"fr-FR\" sz=\"3200\" spc=\"-1\" strike=\"noStrike\">\n          <a:solidFill>\n            <a:srgbClr val=\"000000\"/>\n          </a:solidFill>\n          <a:uFill>\n            <a:solidFill>\n              <a:srgbClr val=\"ffffff\"/>\n            </a:solidFill>\n          </a:uFill>\n          <a:latin typeface=\"Arial\"/>\n        </a:rPr>\n        <a:t>Hello World</a:t>\n      </a:r>\n      <a:endParaRPr b=\"0\" lang=\"fr-FR\" sz=\"1800\" spc=\"-1\" strike=\"noStrike\">\n        <a:solidFill>\n          <a:srgbClr val=\"000000\"/>\n        </a:solidFill>\n        <a:uFill>\n          <a:solidFill>\n            <a:srgbClr val=\"ffffff\"/>\n          </a:solidFill>\n        </a:uFill>\n        <a:latin typeface=\"Arial\"/>\n      </a:endParaRPr>\n    </a:p>\n  </p:txBody>\n</p:sp>";