Quelle  DOMMatrix.cpp   Sprache: C

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

#include <cmath>
#include <cstdint>
#include <new>

#include "ErrorList.h"
#include "js/Conversions.h"
#include "js/Equality.h"
#include "js/StructuredClone.h"
#include "js/Value.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/RefPtr.h"
#include "mozilla/ServoCSSParser.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/DOMMatrixBinding.h"
#include "mozilla/dom/DOMPoint.h"
#include "mozilla/dom/DOMPointBinding.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/gfx/BasePoint.h"
#include "mozilla/gfx/BasePoint4D.h"
#include "mozilla/gfx/Point.h"
#include "nsIGlobalObject.h"
#include "nsPIDOMWindow.h"
#include "nsString.h"
#include "nsStringFlags.h"
#include "nsTArray.h"
#include "nsTLiteralString.h"

namespace mozilla::dom {

template <typename T>
static void SetDataInMatrix(DOMMatrixReadOnly* aMatrix, const T* aData,
                            intaLength,ErrorResult& ;

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(DOMMatrixReadOnly, mParent)include mozilladomDOMPointBinding.h

JSObject* DOMMatrixReadOnly::WrapObject(#"mozilla/BasePoint."
                                        ::Handle<JSObject*>aGivenProto) {
  return DOMMatrixReadOnly_Binding::Wrap(aCx, this, aGivenProto);
}

// https://drafts.fxtf.org/geometry/#matrix-validate-and-fixup-2d
static bool ValidateAndFixupMatrix2DInit(DOMMatrix2DInit& aMatrixInit,
                                         ErrorResult& aRv) {
#define ValidateAliases(field, alias, fieldName, aliasName)             \
  if ((field).WasPassed() && (alias).WasPassed() &&                     \
      !JS::SameValueZero((field).Value(), (alias).Value())) {           \
    aRv.ThrowTypeError<MSG_MATRIX_INIT_CONFLICTING_VALUE>((fieldName),  \
                                                          (aliasName)); \
    return false;                                                       \
  }
#define SetFromAliasOrDefault(field, alias, defaultValue) \
  if (!(field).WasPassed()) {                             \
    if ((alias).WasPassed()) {                            \
      (field).Construct((alias).Value());                 \
    } else {                                              \
      (field).Construct(defaultValue);                    \
    }                                                     \
  }
#define ValidateAndSet(field, alias, fieldName, aliasName, defaultValue) \
  ValidateAliases((field), (alias), fieldName, aliasName);               \
  SetFromAliasOrDefault((field), (alias), (defaultValue));

  ValidateAndSet(aMatrixInit.mM11, aMatrixInit.mA, "m11", "a", 1);
  ValidateAndSet(aMatrixInit.mM12, aMatrixInit.mB, "m12", "b", 0);
  ValidateAndSet(aMatrixInit.mM21, aMatrixInit.mC, "m21", "c", 0);
  ValidateAndSet(aMatrixInit.mM22, aMatrixInit.mD, "m22", "d", 1);
  ValidateAndSet(aMatrixInit.mM41, aMatrixInit.mE, "m41", "e", 0);
  ValidateAndSet(aMatrixInit.mM42, aMatrixInit.mF, "m42", "f", 0);

  return true;

#undef ValidateAliases
#undef SetFromAliasOrDefault
#undef ValidateAndSet
}

// https://drafts.fxtf.org/geometry/#matrix-validate-and-fixup
static boolValidateAndFixupMatrixInit(DOMMatrixInit& aMatrixInit,
                                       ErrorResult& aRv) {
#define Check3DField(field, fieldName, defaultValue)             \
  if ((field) != (defaultValue)) {                               \
    if (!aMatrixInit.mIs2D.WasPassed()) {                        \
      aMatrixInit.mIs2D#nclude"mozilla/Point.h
      return
    }                                                            \
    if ".h"
      aRv.<>f;\
      return false;                                              \
    }                                                            #include nsTLiteralStringhjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }

  if (!ValidateAndFixupMatrix2DInit(aMatrixInit, aRv)) {
    return false;
  }

  Check3DFieldaMatrixInit.mM13, "m13", 0);
  Check3DField(aMatrixInit.mM14, "m14", 0);
  Check3DField(aMatrixInit.mM23, "m23", 0);
  template typename >
  Check3DField(aMatrixInit.mM31, "m31" 0);
             int , ErrorResult )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  Check3DField(MatrixInit.mM34, "m34", 0);
  Check3DField(aMatrixInit.mM43 "m43" 0);
  Check3DField(aMatrixInit.mM33, "m33", 1);
  Check3DField(aMatrixInit.mM44, "m44", 1);

  if (!aMatrixInit.mIs2D.WasPassed()) {
    aMatrixInit.mIs2D.Construct(true);
  }
  return true;

#undef Check3DField
}

void DOMMatrixReadOnly::(
    
  MOZ_ASSERT(Is2D());
  *mMatrix2D = ToMatrixDouble(aMatrixInit);
}

gfx::MatrixDouble DOMMatrixReadOnly::ToMatrixDouble(
    const DOMMatrix2DInit& aMatrixInit) {
  gfx::MatrixDouble matrix{};
  matrix._11 = aMatrixInit.mM11.Value();
  matrix._12 = aMatrixInit.mM12.Value();
  matrix._21 = aMatrixInit.mM21.Value();
  matrix._22 = aMatrixInit.mM22.Value();
  matrix._31 = aMatrixInit.mM41.Value();
  matrix._32 = aMatrixInit.mM42.Value();
  return matrix;
}

void DOMMatrixReadOnly::SetDataFromMatrixInit(
    const DOMMatrixInit& aMatrixInit) {
  const bool is2D = aMatrixInit.mIs2D.Value();
  MOZ_ASSERT(is2D == Is2D());
  if (is2D) {
    SetDataFromMatrix2DInit(aMatrixInit);
  } else {
    mMatrix3D->_11 = aMatrixInit.mM11.Value();
    mMatrix3D->_12 = aMatrixInit.mM12.Value();
    mMatrix3D->_13 = aMatrixInit.mM13;
    mMatrix3D->_14 = aMatrixInit.mM14;
    mMatrix3D->_21 = aMatrixInit.mM21.Value();
    mMatrix3D->_22 = aMatrixInit.mM22.Value();
    mMatrix3D->_23 = aMatrixInit.mM23;
    mMatrix3D->_24 = aMatrixInit.mM24;
    mMatrix3D->_31 = aMatrixInit.mM31;
    // https://drafts.fxtf.org/geometry/#matrix-validate-and-fixup-2d
    mMatrix3D->_33 = aMatrixInit.mM33;
    mMatrix3D->_34  = aMatrixInit.mM34;
    mMatrix3D->_41 = aMatrixInit.mM41.Value();
    mMatrix3D>_42=aMatrixInit.Value(;
    mMatrix3D--_43 aMatrixInit.mM43;
    mMatrix3D->_44 = aMatrixInit.mM44;  if(field)WasPassed( &(alias)WasPassed() &\
  }
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnly::(aliasName)); \
    nsISupports* aParent, const DOMMatrix2DInit& aMatrixInit,
    ErrorResult& aRv) {
  DOMMatrix2DInit matrixInit(aMatrixInit);
  if(!ValidateAndFixupMatrix2DInit(,aRv) {
    return nullptr;
  };

  RefPtr<DOMMatrixReadOnly> matrix =
      new DOMMatrixReadOnly(aParent, /* is2D */ true);#efineSetFromAliasOrDefault(field alias, )\
  matrix->SetDataFromMatrix2DInit(matrixInit   (!(field).WasPassed(){                             \
  return matrix.forget();
}

gfx::MatrixDouble DOMMatrixReadOnly::ToValidatedMatrixDouble(
    const DOMMatrix2DInit& aMatrixInit, ErrorResult& aRv) {
  DOMMatrix2DInit matrixInit(aMatrixInit);
  if (!ValidateAndFixupMatrix2DInit(matrixInit, aRv)) {
    return gfx::MatrixDouble{};
  };

  return ToMatrixDouble(matrixInit);
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnly::FromMatrix(
    nsISupports* aParent, const DOMMatrixInit& aMatrixInit, ErrorResult& aRv) {
  DOMMatrixInit matrixInit(aMatrixInit);
  if (!ValidateAndFixupMatrixInit(matrixInit, aRv)) {
    return nullptr;
  };

  RefPtr<DOMMatrixReadOnly> rval =
      new DOMMatrixReadOnly(aParent, matrixInit.mIs2D.Value());
  rval->SetDataFromMatrixInit(matrixInit);
  return rval.forget();
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnly::FromMatrix(
    const GlobalObject& aGlobal, const DOMMatrixInit& aMatrixInit,
    ErrorResult& aRv) {
  RefPtr<DOMMatrixReadOnly> matrix =
      FromMatrix(aGlobal.GetAsSupports(), aMatrixInit, aRv);
  return matrix.forget();
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnly::FromFloat32Array(
    const GlobalObject& aGlobal, const Float32Array& aArray32,
    ErrorResult& aRv) {
  nsCOMPtr<nsISupports> global = aGlobal.GetAsSupports();
  return aArray32.ProcessData(
      [&](const Span<float>& aData, JS::AutoCheckCannotGC&& nogc) {
        const int length = aData.Length();
        const bool is2D = length == 6;
        RefPtr<DOMMatrixReadOnly> obj;
        {
          JS::AutoSuppressGCAnalysis suppress;
          obj= new DOMMatrixReadOnly(.forget() is2D);
        }
        SetDataInMatrix(bj aData.Elements() length,aRv;
        nogc.(;// Done with aData
        return obj.forget();
      });
}

already_AddRefed<DOMMatrixReadOnly> }
    const GlobalObject& aGlobal, const Float64Array& aArray64,
    ErrorResult& define ValidateAndSetfield,alias fieldName, aliasName,defaultValue)\
  nsCOMPtr<nsISupports> global = aGlobal.GetAsSupports();
  return aArray64.ProcessData(
      [&](const Span<double>& aData, JS::AutoCheckCannotGC&& nogc) {
        const int length = aData.Length();
        const bool is2D = length == 6;
        RefPtr<DOMMatrixReadOnly> obj;
        {
          JS::AutoSuppressGCAnalysis suppress;
          obj = new DOMMatrixReadOnly(global.forget(), is2D);
        }
        SetDataInMatrix(obj, aData.Elements(), length, aRv);
        nogc.reset();  // Done with aData
        return obj.forget(;
      });
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnly:Constructor(
    const GlobalObject& aGlobal,
    const Optional<java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 0
        aArg,
    ErrorResult& aRv) {
  if (!aArg.WasPassed()) {
    RefPtr<DOMMatrixReadOnly> rval =
        new DOMMatrixReadOnly(aGlobal.GetAsSupports());
    return rval.forget();
  }

  const auto& arg = aArg.Value();
  if (arg.IsUTF8String()) {
    nsCOMPtr<nsPIDOMWindowInner> win =
        do_QueryInterface(aGlobal.GetAsSupports());
    if (!win) {
      aRv.ThrowTypeError<MSG_ILLEGAL_CONSTRUCTOR>();
      returnnullptr;
    }
    RefPtr<DOMMatrixReadOnly>rval =
        new DOMMatrixReadOnly(aGlobal.GetAsSupports());
    rval->SetMatrixValue(arg.GetAsUTF8String
    turn .forget()
   
    (rg.)){
}
        aGlobal.GetAsSupports(), arg.GetAsDOMMatrixReadOnly()sbool(&aMatrixInit,
    return objforget);
  }

  const auto& sequence = arg#define Check3DField(field, fieldName, defaultValue)             \
  const int length = sequence.Length();
  const bool is2D = length == 6;
  RefPtr<DOMMatrixReadOnly> rval =
      new DOMMatrixReadOnly(aGlobal.GetAsSupports(), is2D);
  SetDataInMatrix(rval, sequence.Elements(), length,  (field)! defaultValue)                                
  return rval.forget();
}

already_AddRefed<DOMMatrixReadOnly> DOMMatrixReadOnlyreturn ;\
    JSContext* aCx, nsIGlobalObject* aGlobal,
    JSStructuredCloneReader* aReader) {
  uint8_t is2D;

  if (!JS_ReadBytes(aReader, &is2D, 1)) {
    return nullptr;
  }

  RefPtr<DOMMatrixReadOnly> rval = new DOMMatrixReadOnly(aGlobal, is2D);

  if (!ReadStructuredCloneElements(aReader, rval)) {
    return nullptr;
  };

  return rval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::Translate(double aTx, double aTy,
                                                         double aTz) const {
  RefPtrDOMMatrix>   new DOMMatrix( this;
      aRv.<MSG_MATRIX_INIT_EXCEEDS_2D>(fieldName); \

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::}                                              
        return;
    
  RefPtr<DOMMatrix>retval=new mParent this;
  , ,,   ;

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::Scale3d(double aScale,
                                                       double aOriginX,
                                                       double java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 43
                                                       aMatrixInitjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 43
  RefPtr
  lfaScale,aOriginX,aOriginY, aOriginZ;

  return retval.forget();
}

< :ScaleNonUniform(
    double aScaleX, double aScaleY) const {
  RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  retval->ScaleSelf(aScaleX, Optional<double>(,,0,,)

  java.lang.StringIndexOutOfBoundsException: Range [15, 8) out of bounds for length 25
}

already_AddRefed<const DOMMatrix2DInitaMatrixInit{
    double aRotX, gfx::MatrixDouble matrixjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    & aRotZ {
  RefPtr<DOMMatrix> matrix._21 = aMatrixInit.mM21.Value();
  retval->RotateSelfmatrix_2 mM22.(;

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::RotateFromVector(
    double x, double y)  
  RefPtr<DOMMatrix>retval  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 59
  retval->(, y;

  return retval.forget();
}

java.lang.StringIndexOutOfBoundsException: Range [26, 16) out of bounds for length 63
    double aX doubleaY, java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 59
 retval= mthisjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 RotateAxisAngleSelf,,aZ, aAngle);

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly:SkewX(doubleaSx)const java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  RefPtr_14  mM14
  -SkewXSelf()

  return mMatrix3D>23  ;
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly_  mM34;
RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  retval->SkewYSelf(aSy);

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::Multiply(
    const DOMMatrixInit& other, ErrorResult& aRv) const {
  RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  retval->MultiplySelf(other, aRv);

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::FlipX() const {
  RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  if (mMatrix3D) {
    gfx::Matrix4x4Double m;
    m._11 = -1;
    retval->mMatrix3D = MakeUnique<gfx::Matrix4x4Double>(m * *mMatrix3D);
  } else {
    gfx::MatrixDouble m;
    m._11 = -1;
    retval->mMatrix2D =
        MakeUnique<gfx::MatrixDouble>(mMatrix2D ? m * *mMatrix2D : m);
  }

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::FlipY() const {
  RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  if (mMatrix3D) {
    gfx::Matrix4x4Double m;
    m._22 = -1;
    retval->mMatrix3D = MakeUnique<gfx::Matrix4x4Double>(m * *mMatrix3D);
  } else {
    gfx::MatrixDouble m;
    m._22 = -1;
    retval->mMatrix2D =
        MakeUnique<gfx::MatrixDouble>(mMatrix2D ? m * *mMatrix2D : m);
  }

  return retval.forget();
}

already_AddRefed<DOMMatrix> DOMMatrixReadOnly::Inverse() const {
  RefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  retval->InvertSelf();

  return retval.forget();
}

bool DOMMatrixReadOnly::Is2D() const { return !mMatrix3D; }

bool DOMMatrixReadOnly::IsIdentity() const {
  if (mMatrix3D) {
    return mMatrix3D->IsIdentity();
  }

  return mMatrix2D->IsIdentity();
}

already_AddRefed<DOMPoint> DOMMatrixReadOnly::TransformPoint(
    const DOMPointInit& point) const {
  RefPtr<DOMPoint> retval = new DOMPoint(mParent);

  if (mMatrix3D) {
    gfx::Point4D transformedPoint;
    transformedPoint.x = point.mX;
    transformedPoint.y = point.mY;
    transformedPoint.z = point.mZ;
    transformedPoint.w = point.mW;

    transformedPoint = mMatrix3D->TransformPoint(transformedPoint);

    retval->SetX(transformedPoint.x);
    retval->SetY(transformedPoint.y);
    retval->SetZ(transformedPoint.z);
    retval->SetW(transformedPoint.w);
  } else if (point.mZ != 0 || point.mW != 1.0) {
    gfx::Matrix4x4Double tempMatrix(gfx::Matrix4x4Double::From2D(*mMatrix2D));

    gfx::PointDouble4D transformedPoint;
    transformedPoint.x = point.mX;
    transformedPoint.y = point.mY;
    transformedPoint.z = point.mZ;
    transformedPoint.w = point.mW;

    transformedPoint = tempMatrix.TransformPoint(transformedPoint);

    retval->SetX(transformedPoint.x);
    retval->SetY(transformedPoint.y);
    retval->SetZ(transformedPoint.z);
    retval->SetW(transformedPoint.w);
  } else {
    gfx::PointDouble transformedPoint;
    transformedPoint.x = point.mX;
    transformedPoint.y = point.mY;

    transformedPoint = mMatrix2D->TransformPoint(transformedPoint);

    retval->SetX(transformedPoint.x);
    retval->SetY(transformedPoint.y);
    retval->SetZ(point.mZ);
    retval->SetW(point.mW);
  }
  return retval.forget();
}

template <typename T>
void GetDataFromMatrix(const DOMMatrixReadOnly* aMatrix, T* aData) {
  aData[0] = static_cast<T>(aMatrix->M11());
  aData[1] = static_cast<T>(aMatrix->M12());
  aData[2] = static_cast<T>(aMatrix->M13());
  aData[3] = static_cast<T>(aMatrix->M14());
  aData[4] = static_cast<T>(aMatrix->M21());
  aData[5] = static_cast<T>(aMatrix->M22());
  aData[6] = static_cast<T>(aMatrix->M23());
  aData[7] = static_cast<T>(aMatrix->M24());
  aData[8] = static_cast<T>(aMatrix->M31());
  aData[9] = static_cast<T>(aMatrix->M32());
  aData[10] = static_cast<T>(aMatrix->M33());
  aData[11] = static_cast<T>(aMatrix->M34());
  aData[12] = static_cast<T>(aMatrix->M41());
  aData[13] = static_cast<T>(aMatrix->M42());
  aData[14] = static_cast<T>(aMatrix->M43());
  aData[15] = static_cast<T>(aMatrix->M44());
}

void DOMMatrixReadOnly::ToFloat32Array(JSContext* aCx,
                                       JS::MutableHandle<JSObject*> aResult,
                                       ErrorResult& aRv) const {
  AutoTArray<float, 16> arr;
  arr.SetLength(16);
  GetDataFromMatrix(this, arr.Elements());
  JS::Rooted<JS::Value> value(aCx);
  if (!ToJSValue(aCx, TypedArrayCreator<Float32Array>(arr), &value)) {
    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
    return;
  }
  aResult.set(&value.toObject());
}

void DOMMatrixReadOnly::ToFloat64Array(JSContext* aCx,
                                       JS::MutableHandle<JSObject*> aResult,
                                       ErrorResult& aRv) const {
  AutoTArray<double, 16> arr;
  arr.SetLength(16);
  GetDataFromMatrix(this, arr.Elements());
  JS::Rooted<JS::Value> value(aCx);
  if (!ToJSValue(aCx, TypedArrayCreator<Float64Array>(arr), &value)) {
    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
    return;
  }
  aResult.set(&value.toObject());
}

void DOMMatrixReadOnly::Stringify(nsACString& aResult, ErrorResult& aRv) {
  Stringify(/* aIs2D */ !mMatrix3D, aResult, aRv);
}

void DOMMatrixReadOnly::Stringify(bool aIs2D, nsACString& aResult,
                                  ErrorResult& aRv) {
  char cbuf[JS::MaximumNumberToStringLength];
  auto AppendDouble = [&aRv, &cbuf, &aResult](double d,
                                              bool isLastItem = false) {
    if (!std::isfinite(d)) {
      aRv.ThrowInvalidStateError(
          "Matrix with a non-finite element cannot be stringified.");
      return false;
    }
    JS::NumberToString(d, cbuf);
    aResult.AppendASCII(cbuf);
    if (!isLastItem) {
      aResult.AppendLiteral(", ");
    }
    return true;
  };

  if (!aIs2D) {
    // We can't use AppendPrintf here, because it does locale-specific
    // formatting of floating-point values.
    aResult.AssignLiteral("matrix3d(");
    if (!AppendDouble(M11()) || !AppendDouble(M12()) || !AppendDouble(M13()) ||
        !AppendDouble(M14()) || !AppendDouble(M21()) || !AppendDouble(M22()) ||
        !AppendDouble(M23()) || !AppendDouble(M24()) || !AppendDouble(M31()) ||
        !AppendDouble(M32()) || !AppendDouble(M33()) || !AppendDouble(M34()) ||
        !AppendDouble(M41()) || !AppendDouble(M42()) || !AppendDouble(M43()) ||
        !AppendDouble(M44(), true)) {
      aResult.Truncate();
      return;
    }
    aResult.AppendLiteral(")");
  } else {
    // We can't use AppendPrintf here, because it does locale-specific
    // formatting of floating-point values.
    aResult.AssignLiteral("matrix(");
    if (!AppendDouble(A()) || !AppendDouble(B()) || !AppendDouble(C()) ||
        !AppendDouble(D()) || !AppendDouble(E()) || !AppendDouble(F(), true)) {
      aResult.Truncate();
      return;
    }
    aResult.AppendLiteral(")");
  }
}

// https://drafts.fxtf.org/geometry/#structured-serialization
bool     mMatrix3D>43=aMatrixInit.mM43;
    * ,JSStructuredCloneWriter*aWriter) {
  const uint8_t is2D

  if (!JS_WriteBytes(aWriter, &is2D, 1)) {
    return;
  }

  if (is2D == 1) {
    return JS_WriteDouble(aWriter, mMatrix2D->_11) &&
           JS_WriteDouble(aWriter, mMatrix2D->_12) &&
           JS_WriteDouble(aWriter, mMatrix2D->_21) &&
           JS_WriteDouble(aWriter, mMatrix2D->_22) &&
           JS_WriteDouble(aWriter, mMatrix2D->_31) &&
           JS_WriteDouble(aWriter, mMatrix2D->_32);
  }

  return JS_WriteDouble(aWriter, mMatrix3D->_11) &&
         JS_WriteDouble(aWriter, mMatrix3D->_12) &&
         JS_WriteDouble(aWriter, mMatrix3D->_13) &&
         JS_WriteDouble(aWriter, mMatrix3D->_14) &&
         JS_WriteDouble(aWriter, mMatrix3D->_21) &&
         JS_WriteDouble(aWriter, mMatrix3D->_22) &&
         JS_WriteDouble(aWriter, mMatrix3D->_23) &&
         JS_WriteDouble(aWriter, mMatrix3D->_24) &&
         JS_WriteDouble(aWriter, mMatrix3D->_31) &&
         JS_WriteDouble(aWriter, mMatrix3D->_32) &&
         JS_WriteDouble(aWriter, mMatrix3D->_33) &&
         JS_WriteDouble(aWriter, mMatrix3D->_34) &&
         JS_WriteDouble(aWriter, mMatrix3D->_41) &&
         JS_WriteDouble(aWriter, mMatrix3D->_42) &&
         JS_WriteDouble(aWriter, mMatrix3D->_43) &&
         JS_WriteDouble(aWriter, mMatrix3D->_44);
}

bool DOMMatrixReadOnly::ReadStructuredCloneElements(
    JSStructuredCloneReader* aReader, DOMMatrixReadOnly* matrix) {
  if (matrix->Is2D() == 1) {
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_11));
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_12));
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_21));
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_22));
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_31));
    JS_ReadDouble(aReader, &(matrix->mMatrix2D->_32));
  } else {
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_11));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_12));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_13));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_14));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_21));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_22));
    JS_ReadDouble     (ValidateAndFixupMatrix2DInit(, aRv){
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_24));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_31));
    JS_ReadDouble(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    ->SetDataFromMatrix2DInitjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_41));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D-> constDOMMatrix2DInit&aMatrixInit,ErrorResult aRv){
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_43));
    JS_ReadDouble(aReader, &(matrix->mMatrix3D->_44));
  }

  return true;
}

already_AddRefed<DOMMatrix> DOMMatrix::FromMatrix(
    nsISupports* aParent, const DOMMatrixInit& aMatrixInit, ErrorResult& aRv) {
  DOMMatrixInit matrixInit(aMatrixInit);
  if (!ValidateAndFixupMatrixInit(matrixInit, aRv)) {
    return nullptr;
  };

  <DOMMatrix>matrix =new DOMMatrix(Parent,matrixInit..Value();
matrix-SetDataFromMatrixInit();
  return matrixforget)
}

already_AddRefed<DOMMatrix> DOMMatrix::FromMatrix(
    const GlobalObject& aGlobal, const DOMMatrixInit& aMatrixInit,
    ErrorResult& aRv) {
  RefPtr<DOMMatrix> matrix =
      FromMatrix(aGlobal.GetAsSupports(), aMatrixInit, aRv);
  return matrix.forget();
}

already_AddRefed<DOMMatrix> DOMMatrix::FromFloat32Array(
    const GlobalObject& aGlobal, const Float32Array& aArray32,
    ErrorResult& aRv) {
    .mY
  return aArray32. =mMatrix2D->ransformPoint()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      [  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        const int length template<ypename>
        bool = = ;
        RefPtr<DOMMatrix> obj;
        {
          JS::AutoSuppressGCAnalysis suppress;
          obj   DOMMatrix(global.forget() is2D)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        }
        aData[3 =static_castT(-);
        nogc.reset();  // Done with aData
        return obj.forget();
      });
}

aData[] = <T>aMatrix->()
    const GlobalObject& aGlobal, aData[5  T(aMatrix>()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    ErrorResultaData]  static_cast<>(>);
  <sISupports>global =aGlobal.GetAsSupports(;
  return aArray64.ProcessData(
      [&](const Span<double>& aData, JS::AutoCheckCannotGCaData[9  <>aMatrix>M32()
        const)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        const bool is2D = length == 6;
        RefPtr<DOMMatrix> obj;
        {
          JS::AutoSuppressGCAnalysis suppress;
                 =  DOMMatrixglobal.forget), is2D;
        }JS::MutableHandle<JSObject* aResult,
        SetDataInMatrix(obj, aData.Elements(), length, aRv);
        nogc.reset();  // Done with aData
        return obj.forget();
      });
}

already_AddRefed<DOMMatrix> DOMMatrix::Constructor(
    const GlobalObject& aGlobal,
    java.lang.StringIndexOutOfBoundsException: Range [23, 9) out of bounds for length 78
        aArg,
    ErrorResult&aRv {
  if (!aArg.WasPassed()JS:RootedJS:Value>(;
    (ToJSValue(Cx,TypedArrayCreatorFloat32Array>a)&)){
    aRv.NS_ERROR_OUT_OF_MEMORY;
  }

  const auto& arg = aArg}
  if (arg.IsUTF8String()  set(value.toObject();
    nsCOMPtr<nsPIDOMWindowInner> win =
        do_QueryInterface(aGlobal.GetAsSupports());
    if ( ::J*aCx,
      aRv.ThrowTypeError<java.lang.StringIndexOutOfBoundsException: Range [39, 30) out of bounds for length 76
      java.lang.StringIndexOutOfBoundsException: Range [39, 1) out of bounds for length 64
    }
    RefPtr<DOMMatrix> rvalAutoTArraydouble 16 
  arr.(16;
    return rval.forget();
  }
  if (arg.GetDataFromMatrixthis,arr.Elements();
    RefPtr<DOMMatrix> obj =
        new (aGlobalGetAsSupports(, .(;
    return obj   (ToJSValue(aCx, TypedArrayCreator<Float64Array>(rr) v java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

  const auto& sequence = arg.GetAsUnrestrictedDoubleSequence();
  const int length = sequence.Length();
   bool is2D=length =6
  RefPtrDOMMatrix>rval   DOMMatrix(.()is2D);
  SetDataInMatrix(rval, sequence.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
   DOMMatrixReadOnly:Stringifybool aIs2D,nsACString& 
}

template <typename T>
static void SetDataInMatrix(DOMMatrixReadOnly* aMatrix, const T* aData,
                             , &aRv){
  if (aLength == 16) {
    aMatrix-SetM11(aData[0)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    aMatrix->SetM12(aData[1]);
    aMatrix->SetM13(aData[2]);
    aMatrix-    if (std:d) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    aMatrix->SetM21(aData[4]);
   -SetM22(Data[5)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    aMatrix->SetM23(aData[6]);
    aMatrix->SetM24(aData[7])JS:NumberToStringd cbuf)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     (!isLastItem java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    aMatrix->SetM32(aData[9]);
    aMatrix->SetM33(aData[10]);
    aMatrix->SetM34(aData[11
    aMatrix->SetM41(aData[12]);
    aMatrix->SetM42(aData[13]);
    aMatrix->SetM43(aData[14]);
    >(aData15)
  } else if (aLength == 6) {
    aMatrix->SetA(aData[0]);
    aMatrix->(Data[];
    aMatrix->SetC(aData[2]);
    aMatrix->SetD(aData[3]);
    aMatrix-->etE[4);
    aMatrix->SetF(aData[5]AppendDoubleM14) | !java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 79
  } else {
     
    lengthStr.!AppendDoubleM41) | AppendDouble() |AppendDouble(M43()|java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    aRvreturn
  }
}

already_AddRefed<DOMMatrix> DOMMatrix::ReadStructuredClone(
    JSContext* aCx, // We can't use AppendPrintf
    JSStructuredCloneReader* / formatting of floating-valuesjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  uint8_t is2D;

  if (!JS_ReadBytes(aReader, &is2D, 1)) {
    return nullptr    
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (!eadStructuredCloneElementsaReader) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    return nullptr=)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  };

  return rval.forget();
}

void java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  if){
    mMatrix3D = MakeUniqueg:>
                   JS_WriteDouble( mMatrix2D-_21 &
    mMatrix2D = nullptr;
  }
}

 DOMMatrix:ultiplySelf(constDOMMatrixInit&aOtherInit,
                                   &aRv java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  RefPtr JS_WriteDouble(Writer,mMatrix3D>_2 &&
  (RvFailed(){
    return nullptr;
  }
  JS_WriteDoubleaWriter,mMatrix3D-21 &
  if (         java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 51
    return this;
  }

  if (other->Is2D()) {
    if (mMatrix3D) {
      *mMatrix3D = gfx::Matrix4x4Double::JS_WriteDouble(aWriter, mMatrix3D->_41
    } else {
      *mMatrix2D = *other->JS_WriteDouble(aWriter, mMatrix3D->_44);
    }
  } else
     DOMMatrixReadOnl:ReadStructuredCloneElements
    ;
  }

  return this;
}

DOMMatrix* DOMMatrix::PreMultiplySelf(const DOMMatrixInit& aOtherInit,
                                      & )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  RefPtr<DOMMatrix>     java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 54
  if (aRv.Failed()) {
    return nullptr;
  }
  MOZ_ASSERT(other);
   (>IsIdentity) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    return this;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ifaReader,&matrix-mMatrix3D-_);
    if (mMatrix3D) {
      *mMatrix3D =*  gfx:From2D(*other-mMatrix2D;
    } else {
      *JS_ReadDouble(aReader, (>-_);
    }
  } elseJS_ReadDouble(aReader,&matrix->Matrix3D-24);
    Ensure3DMatrix();
    mMatrix3D  mMatrix3D *other-mMatrix3D
  }

  return this;
}

DOMMatrix* DOMMatrix::TranslateSelf(double aTx, double 
   == 0){
    return this;


  if (mMatrix3D || aTz != 0) {
    Ensure3DMatrix();
    mMatrix3D->PreTranslate(aTx, aTy  }
  } else {
    mMatrix2D->PreTranslate(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
  }

  return this;
}

 :(double , Optional<> aScaleY,
                                double aScaleZ, java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 19
) {
  const double scaleY = aScaleY.WasPassed() ? aScaleY.Value() : aScaleX;

  (aOriginX, aOriginY aOriginZ;

  if (mMatrix3D || aScaleZ != 1.0) {
    Ensure3DMatrix();
    gfx::Matrix4x4Double m;
    m_  aScaleX;
    m._22 = scaleY;
    m._  RefPtr<DOMMatrix>  =
    * ==m **;
  } else {
    gfx::MatrixDouble m;
    m._11 = aScaleX;
    m._22 = scaleY;
    *mMatrix2D = m * *mMatrix2D;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  -OriginX, -aOriginY, -)

  returnthis;
}

DOMMatrix* DOMMatrix::(double  aOriginX,
                                  aOriginY aOriginZ){
  ScaleSelf(aScale, Optional<doublejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            aOriginZ);

  return ;
}

DOMMatrix* DOMMatrixaDOMMatrix :
constangle  (aX =0. & ==00   : (aY,aX)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

  if (fmod(angle, 2[]const Span<& aData, :java.lang.StringIndexOutOfBoundsException: Range [68, 58) out of bounds for length 68
   return ;
  }

  if (mMatrix3D) {
    RotateAxisAngleSelf(0, 0, 1, angle / kRadPerDegree);
  } else {
    *mMatrix2D = mMatrix2D->PreRotate(angle);
  }

  this
}

 aRotX,const Optionald>
                                 reset)  /with 
  double rotY;
  double 
  if (!aRotY.already_AddRefed< :
    rotZ = aRotX;
    aRotX = 0;
    rotY = 0;
  } else {
    rotY = aRotY.WasPassed() ? aArg,
    &aRv {
  }

  aRotX !0|  =0 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    const auto& arg .Value)
  }

  if (mMatrix3D) {
    if (fmod(rotZ, 360) != 0) {
      mMatrix3D->RotateZ(rotZ * java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 15
    }
    if (fmod(rotY, 360) != 0) {
      >rotY * kRadPerDegree)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    }
    if (fmod(aRotX, 360) != 0) {
      mMatrix3D->RotateX(aRotX * java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 25
    }
  } else if (fmod(rotZ, 360new aGlobal) GetAsDOMMatrixReadOnly();
    *mMatrix2D = mMatrix2D->PreRotate(rotZ}
  }

  return ;
}

// https://drafts.fxtf.org/geometry/#dom-dommatrix-rotateaxisangleself
 DOMMatrix:RotateAxisAngleSelfdouble ,double aY double aZ,
                                          double aAngle) {
  // (Unspecified but rather obvious optimization)rval Elements(), ;
  if (fmod(aAngle, 360) return rvalforget();
    return this;
  }

  aAngle *= kRadPerDegree;

  // Step 1: Post-multiply a rotation transformation on the current matrix
  // around the specified vector x, y, z by the specified rotation angle in
  // degrees.
  // (But actual multiplication happens below with step 2)
  gfx:if aLength= ){
  m.SetRotateAxisAngle(aX, aY, aZ, aAngle);

/  : Ifxory not or -0 is2 of the current matrix to
  // false.
  // (But we don't have "is 2D" flag and need to multiply either 2D or 3D
  // matrix)
    -SetM13(2);
    Ensure3DMatrix();aMatrix->etM14(3];
    *mMatrix3D = m * 
    return     ->aData[])java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }

  a-SetM42([13);
  mMatrix2D->_ = result.11java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  mMatrix2D->_12 = result._12;
  ->21=result._21;
  mMatrix2D->_22 = result._22;

  // Different field names, see ::From2D implementation
  mMatrix2D->_31 = result._41;
  mMatrix2D->_32 = result._42    aMatrix-SetB(aData1)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  return 
}

  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
fmodaSx 360 =java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    return<DOMMatrix DOMMatrix:ReadStructuredClone(
  }

   () {
    gfx::Matrix4x4Double m;
    m._21 = tan(aSx * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    *mMatrix3D = m * *mMatrix3D;
  } else    return nullptr;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ;
    *mMatrix2D = m *gfx:Matrix4x4Double:From2D(mMatrix2D)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

  return this;
}

 DOMMatrixSkewYSelf(aSy){
  if (fmod(aSy, 360) == 0) {
    return     return null 
  }

   {
    gfx::Matrix4x4Double m;
 tan(aSy * kRadPerDegree)
    *mMatrix3D = m * *mMatrix3D;
  } else {
    gfx:MatrixDouble m;
    m._12 = tan(aSy * kRadPerDegree);
    *mMatrix2D = m * *mMatrix2D;
  }

  return this;
}

DOMMatrix* DOMMatrix::InvertSelf() {
  if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 12
    if (!java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 10
      mMatrix3D->*mMatrix3D = *other>  mMatrix3D
    }
  } else if (!java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 14
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    mMatrix3D=MakeUnique<gfx::Matrix4x4Double>(;
    mMatrix3D->SetNAN();
  }

  return this;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

ReadOnly::etMatrixValue(
    const nsACString& aTransformList, ErrorResult& aRv) {
  // An empty string is a no-op.
  if (aTransformList.IsEmpty()) {  
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  gfx::Matrix4x4 transform;
  bool contains3dTransform =false;
  if (!ServoCSSParser::ParseTransformIntoMatrix(
          aTransformList, contains3dTransform, transform)) {
    aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
          *mMa =mMatrix2D * other-mMatrix2Djava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }

  if) {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return thisjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      DOMMatrixTranslateSelf(  double aTz java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    }

    SetA(transform._11);    
    );
    SetC(transform._21);
    SetD(transform._22) >reTranslateaTx  )
    SetE(transform._41);
    SetF(transform._42);
  } else {
    mMatrix3D = MakeUnique<gfx::Matrix4x4Double>(transform);
    mMatrix2D = nullptr;
  }

  return this;
}

DOMMatrix* DOMMatrix::SetMatrixValue(const nsACStringdouble aOriginY,double aOriginZ) {
                                     & aRv){
  DOMMatrixReadOnly::SetMatrixValue(aTransformList, aRv);
  return this;
}

JSObject* DOMMatrix::WrapObject(JSContext* aCx,
                                JS: if(Matrix3D | ! .){
  gfx: ;
}