@loaders.gl/textures 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/ktx2-basis-writer-worker.js

@@ -0,0 +1,343 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // (disabled):../worker-utils/src/lib/node/require-utils.node
+  var require_require_utils = __commonJS({
+    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
+    }
+  });
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var VERSION = true ? "4.0.0-alpha.7" : DEFAULT_VERSION;
+  if (false) {
+    console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+  }
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
+  var onMessageWrapperMap = new Map();
+  var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
+    static set onmessage(onMessage) {
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
+        onMessage(type, payload);
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
+    }
+    static addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    static postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  }
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toModule(require_require_utils());
+  var LATEST = "beta";
+  var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+    }
+    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options) {
+    if (library.startsWith("http")) {
+      return library;
+    }
+    const modules = options.modules || {};
+    if (modules[library]) {
+      return modules[library];
+    }
+    if (!isBrowser) {
+      return `modules/${moduleName}/dist/libs/${library}`;
+    }
+    if (options.CDN) {
+      assert(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${library}`;
+    }
+    return `modules/${moduleName}/src/libs/${library}`;
+  }
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      const response2 = await fetch(libraryUrl);
+      return await response2.arrayBuffer();
+    }
+    if (!isBrowser) {
+      try {
+        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
+      } catch {
+        return null;
+      }
+    }
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const response = await fetch(libraryUrl);
+    const scriptSource = await response.text();
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser) {
+      return node.requireFromString && node.requireFromString(scriptSource, id);
+    }
+    if (isWorker) {
+      eval.call(global_, scriptSource);
+      return null;
+    }
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+
+  // src/lib/utils/version.ts
+  var VERSION3 = true ? "4.0.0-alpha.7" : "beta";
+
+  // src/lib/parsers/basis-module-loader.ts
+  var VERSION4 = true ? "4.0.0-alpha.7" : "beta";
+  var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.wasm`;
+  var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.js`;
+  var loadBasisEncoderPromise;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
+      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+
+  // src/lib/encoders/encode-ktx2-basis-texture.ts
+  async function encodeKTX2BasisTexture(image, options = {}) {
+    const { useSRGB = false, qualityLevel = 10, encodeUASTC = false, mipmaps = false } = options;
+    const { BasisEncoder } = await loadBasisEncoderModule(options);
+    const basisEncoder = new BasisEncoder();
+    try {
+      const basisFileData = new Uint8Array(image.width * image.height * 4);
+      basisEncoder.setCreateKTX2File(true);
+      basisEncoder.setKTX2UASTCSupercompression(true);
+      basisEncoder.setKTX2SRGBTransferFunc(true);
+      basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
+      basisEncoder.setPerceptual(useSRGB);
+      basisEncoder.setMipSRGB(useSRGB);
+      basisEncoder.setQualityLevel(qualityLevel);
+      basisEncoder.setUASTC(encodeUASTC);
+      basisEncoder.setMipGen(mipmaps);
+      const numOutputBytes = basisEncoder.encode(basisFileData);
+      const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
+      return actualKTX2FileData;
+    } catch (error) {
+      console.error("Basis Universal Supercompressed GPU Texture encoder Error: ", error);
+      throw error;
+    } finally {
+      basisEncoder.delete();
+    }
+  }
+
+  // src/ktx2-basis-writer.ts
+  var KTX2BasisWriter = {
+    name: "Basis Universal Supercompressed GPU Texture",
+    id: "ktx2-basis-writer",
+    module: "textures",
+    version: VERSION3,
+    extensions: ["ktx2"],
+    options: {
+      useSRGB: false,
+      qualityLevel: 10,
+      encodeUASTC: false,
+      mipmaps: false
+    },
+    encode: encodeKTX2BasisTexture
+  };
+
+  // src/workers/ktx2-basis-writer-worker.ts
+  (() => {
+    if (!WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const { input, options } = payload;
+            const result = await KTX2BasisWriter.encode?.(input, options);
+            WorkerBody.postMessage("done", { result });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", { error: message });
+          }
+          break;
+        default:
+      }
+    };
+  })();
+})();

package/dist/ktx2-basis-writer.d.ts

@@ -0,0 +1,16 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+import type { ImageDataType } from '@loaders.gl/images';
+/** @todo should be in basis sub-object */
+export type KTX2BasisWriterOptions = {
+    useSRGB?: boolean;
+    qualityLevel?: number;
+    encodeUASTC?: boolean;
+    mipmaps?: boolean;
+};
+/**
+ *  Basis Universal Supercompressed GPU Texture.
+ *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
+ */
+export declare const KTX2BasisWriter: Writer<ImageDataType, unknown, KTX2BasisWriterOptions>;
+export declare const _TypecheckKTX2TextureWriter: Writer;
+//# sourceMappingURL=ktx2-basis-writer.d.ts.map

package/dist/ktx2-basis-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-basis-writer.d.ts","sourceRoot":"","sources":["../src/ktx2-basis-writer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAGtD,0CAA0C;AAC1C,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,OAAO,EAAE,sBAAsB,CAelF,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,MAAwB,CAAC"}

package/dist/ktx2-basis-writer.js

@@ -0,0 +1,26 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter = void 0;
+const version_1 = require("./lib/utils/version");
+const encode_ktx2_basis_texture_1 = require("./lib/encoders/encode-ktx2-basis-texture");
+/**
+ *  Basis Universal Supercompressed GPU Texture.
+ *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
+ */
+exports.KTX2BasisWriter = {
+    name: 'Basis Universal Supercompressed GPU Texture',
+    id: 'ktx2-basis-writer',
+    module: 'textures',
+    version: version_1.VERSION,
+    extensions: ['ktx2'],
+    options: {
+        useSRGB: false,
+        qualityLevel: 10,
+        encodeUASTC: false,
+        mipmaps: false
+    },
+    encode: encode_ktx2_basis_texture_1.encodeKTX2BasisTexture
+};
+// TYPE TESTS - TODO find a better way than exporting junk
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter;

package/dist/lib/encoders/encode-ktx.js

@@ -1,6 +1,10 @@
-import { read } from 'ktx-parse';
-export function encodeKTX(texture) {
-  const ktx = read(texture);
-  return ktx;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeKTX = void 0;
+const ktx_parse_1 = require("ktx-parse");
+function encodeKTX(texture) {
+    const ktx = (0, ktx_parse_1.read)(texture);
+    // post process
+    return ktx;
 }
-//# sourceMappingURL=encode-ktx.js.map
+exports.encodeKTX = encodeKTX;

package/dist/lib/encoders/encode-ktx2-basis-texture.js

@@ -1,35 +1,41 @@
-import { loadBasisEncoderModule } from '../parsers/basis-module-loader';
-export async function encodeKTX2BasisTexture(image, options = {}) {
-  const {
-    useSRGB = false,
-    qualityLevel = 10,
-    encodeUASTC = false,
-    mipmaps = false
-  } = options;
-  const {
-    BasisEncoder
-  } = await loadBasisEncoderModule(options);
-  const basisEncoder = new BasisEncoder();
-
-  try {
-    const basisFileData = new Uint8Array(image.width * image.height * 4);
-    basisEncoder.setCreateKTX2File(true);
-    basisEncoder.setKTX2UASTCSupercompression(true);
-    basisEncoder.setKTX2SRGBTransferFunc(true);
-    basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
-    basisEncoder.setPerceptual(useSRGB);
-    basisEncoder.setMipSRGB(useSRGB);
-    basisEncoder.setQualityLevel(qualityLevel);
-    basisEncoder.setUASTC(encodeUASTC);
-    basisEncoder.setMipGen(mipmaps);
-    const numOutputBytes = basisEncoder.encode(basisFileData);
-    const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
-    return actualKTX2FileData;
-  } catch (error) {
-    console.error('Basis Universal Supercompressed GPU Texture encoder Error: ', error);
-    throw error;
-  } finally {
-    basisEncoder.delete();
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeKTX2BasisTexture = void 0;
+const basis_module_loader_1 = require("../parsers/basis-module-loader");
+/**
+ * Encodes image to Basis Universal Supercompressed GPU Texture.
+ * Code example is taken from here - https://github.com/BinomialLLC/basis_universal/blob/master/webgl/ktx2_encode_test/index.html#L279
+ * BasisEncoder API - https://github.com/BinomialLLC/basis_universal/blob/master/webgl/transcoder/basis_wrappers.cpp#L1712
+ * @param image
+ * @param options
+ */
+async function encodeKTX2BasisTexture(image, options = {}) {
+    // TODO remove default values after writer options will be normalized like it done in load module.
+    const { useSRGB = false, qualityLevel = 10, encodeUASTC = false, mipmaps = false } = options;
+    const { BasisEncoder } = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
+    const basisEncoder = new BasisEncoder();
+    try {
+        const basisFileData = new Uint8Array(image.width * image.height * 4);
+        basisEncoder.setCreateKTX2File(true);
+        basisEncoder.setKTX2UASTCSupercompression(true);
+        basisEncoder.setKTX2SRGBTransferFunc(true);
+        basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
+        basisEncoder.setPerceptual(useSRGB);
+        basisEncoder.setMipSRGB(useSRGB);
+        basisEncoder.setQualityLevel(qualityLevel);
+        basisEncoder.setUASTC(encodeUASTC);
+        basisEncoder.setMipGen(mipmaps);
+        const numOutputBytes = basisEncoder.encode(basisFileData);
+        const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
+        return actualKTX2FileData;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Basis Universal Supercompressed GPU Texture encoder Error: ', error);
+        throw error;
+    }
+    finally {
+        basisEncoder.delete();
+    }
 }
-//# sourceMappingURL=encode-ktx2-basis-texture.js.map
+exports.encodeKTX2BasisTexture = encodeKTX2BasisTexture;

package/dist/lib/encoders/encode-texture.d.ts

@@ -1,4 +1,3 @@
-export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: {
-    cwd?: string;
-}): Promise<string>;
+import { CompressedTextureWriterOptions } from '../../compressed-texture-writer';
+export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: CompressedTextureWriterOptions): Promise<string>;
 //# sourceMappingURL=encode-texture.d.ts.map

package/dist/lib/encoders/encode-texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AAKA,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,GACvB,OAAO,CAAC,MAAM,CAAC,CAkBjB"}
+{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,8BAA8B,EAAC,MAAM,iCAAiC,CAAC;AAK/E,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

package/dist/lib/encoders/encode-texture.js

@@ -1,12 +1,27 @@
-import { ChildProcessProxy } from '@loaders.gl/worker-utils';
-export async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options) {
-  const args = ['texture-compressor', '--type', 's3tc', '--compression', 'DXT1', '--quality', 'normal', '--input', inputUrl, '--output', outputUrl];
-  const childProcess = new ChildProcessProxy();
-  await childProcess.start({
-    command: 'npx',
-    arguments: args,
-    spawn: options
-  });
-  return outputUrl;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeImageURLToCompressedTextureURL = void 0;
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+/*
+ * @see https://github.com/TimvanScherpenzeel/texture-compressor
+ */
+async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options) {
+    // prettier-ignore
+    const args = [
+        // Note: our actual executable is `npx`, so `texture-compressor` is an argument
+        'texture-compressor',
+        '--type', 's3tc',
+        '--compression', 'DXT1',
+        '--quality', 'normal',
+        '--input', inputUrl,
+        '--output', outputUrl
+    ];
+    const childProcess = new worker_utils_1.ChildProcessProxy();
+    await childProcess.start({
+        command: 'npx',
+        arguments: args,
+        spawn: options
+    });
+    return outputUrl;
 }
-//# sourceMappingURL=encode-texture.js.map
+exports.encodeImageURLToCompressedTextureURL = encodeImageURLToCompressedTextureURL;